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  *

    16  */

    17 

    18 #include <hbdataformmodel.h>

    19 #include <hbdataformmodelitem.h>

    20 #include <hblineedit.h>

    21 #include <hbinputeditorinterface.h>

    22 #include <hbcombobox.h>

    23 #include <hbdeviceprogressdialog.h>

    24 #include <sssettingswrapper.h>

    25 #include <psetwrapper.h>

    26 #include <hbaction.h>

    27 #include <hblistwidget.h>

    28 #include <hblistwidgetitem.h>

    29 #include <hblabel.h>

    30 #include <QApplication>

    31 #include <QLocale>

    32 #include <QTranslator>

    33 #include <cpitemdatahelper.h>

    34 #include "cpdivertselectionitem.h"

    35 #include "cpdivertplugingroup.h"

    36 #include "cpplugincommon.h"

    37 #include "cpphonenotes.h"

    38 #include "cppluginlogging.h"

    39 #include "cpdivertitemdata.h"

    40 #include "cpdivertselectioncustomitem.h"

    41 

    42 /*!

    43   CpDivertPluginGroup::CpDivertPluginGroup.

    44  */

    45 CpDivertPluginGroup::CpDivertPluginGroup(CpItemDataHelper &helper)

    46      : CpSettingFormItemData(HbDataFormModelItem::GroupItem, 

    47                              hbTrId("txt_phone_subhead_call_divert"),0),

    48        m_csVoiceCallPage(NULL),

    49        m_DataItemAllVoiceCalls(NULL),

    50        m_DataItemIfBusy(NULL),

    51        m_DataItemIfNotAnswered(NULL),

    52        m_DataItemIfOutOfReach(NULL),

    53        m_DataItemIfNotAvailable(NULL),

    54        m_activeNoteId(0),

    55        m_helper(helper)

    56 {

    57     DPRINT << ": IN";

    58     

    59     // Localization file loading

    60     QTranslator translator; 

    61     QString lang = QLocale::system().name();

    62     QString path = "z:/resource/qt/translations/";

    63     DPRINT << ": loading translation: " << QString(path + "telephone_cp_" + lang);

    64     bool translatorLoaded = translator.load(path + "telephone_cp_" + lang);

    65     DPRINT << ": translator loaded: " << translatorLoaded; 

    66     if (translatorLoaded) {

    67         qApp->installTranslator(&translator);

    68         DPRINT << ": translator installed"; 

    69     }

    70     

    71     m_pSetWrapper = new PSetWrapper; 

    72     DPRINT << ": PSetWrapper created";

    73     

    74     m_ssSettingsWrapper = new SsSettingsWrapper; 

    75     DPRINT << ": SsSettingsWrapper created";

    76     

    77     m_callDivertingWrapper = &m_pSetWrapper->callDivertingWrapper();

    78     QObject::connect(

    79         m_callDivertingWrapper, 

    80         SIGNAL(handleDivertingChanged(const PSCallDivertingCommand&,bool)),

    81         this, 

    82         SLOT(handleDivertingChanged(const PSCallDivertingCommand&,bool)));

    83     QObject::connect(

    84         m_callDivertingWrapper, 

    85         SIGNAL(handleDivertingStatus(QList<PSCallDivertingStatus*>&, bool)),

    86         this, 

    87         SLOT(handleDivertingStatus(QList<PSCallDivertingStatus*>&, bool)));

    88     QObject::connect(

    89         m_callDivertingWrapper, 

    90         SIGNAL(handleDivertingError(int)),

    91         this, 

    92         SLOT(handleDivertingError(int)));

    93     

    94     QObject::connect(

    95         m_callDivertingWrapper, 

    96         SIGNAL(requestDone()),

    97         this,

    98         SLOT(divertRequestProcessed()));

    99 

   100     // Create custom item prototype

   101     m_helper.addItemPrototype(new CpDivertSelectionItem());

   102     

   103     // Create grouped setting items

   104     createVoiceCallItems();

   105     createVideoCallItems();

   106     createVoIPCallItems();

   107     DPRINT << ": OUT";

   108 }

   109 

   110 /*!

   111   CpDivertPluginGroup::~CpDivertPluginGroup.

   112  */

   113 CpDivertPluginGroup::~CpDivertPluginGroup()

   114 {

   115     DPRINT << ": IN";

   116 

   117     delete m_pSetWrapper;

   118     delete m_ssSettingsWrapper;

   119     

   120     DPRINT << ": OUT";

   121 }

   122 

   123 /*!

   124  CpDivertPluginGroup::createVoiceCallItems.

   125  */

   126 void CpDivertPluginGroup::createVoiceCallItems()

   127 {

   128     DPRINT << ": IN";

   129     m_csVoiceCallPage = new CpSettingFormItemData(

   130                 HbDataFormModelItem::GroupPageItem,

   131                 hbTrId("txt_phone_setlabel_service_val_voice_divert"));

   132     appendChild(m_csVoiceCallPage);

   133 

   134     m_DataItemAllVoiceCalls = new CpDivertItemData(

   135             DivertConditionUnconditional,

   136             ServiceGroupVoice,

   137             hbTrId("txt_phone_setlabel_all_calls"),

   138             hbTrId("All voice calls:"), false,

   139             m_helper,

   140             m_csVoiceCallPage);

   141     

   142     addDivertDataItem(m_DataItemAllVoiceCalls, m_csVoiceCallPage);

   143 

   144     m_DataItemIfBusy = new CpDivertItemData(

   145             DivertConditionBusy,

   146             ServiceGroupVoice,

   147             hbTrId("txt_phone_setlabel_if_busy"),

   148             hbTrId("If busy:"), false,

   149             m_helper,

   150             m_csVoiceCallPage);

   151     

   152     addDivertDataItem(m_DataItemIfBusy, m_csVoiceCallPage);

   153 

   154     m_DataItemIfNotAnswered = new CpDivertItemData(

   155             DivertConditionNoReply,

   156             ServiceGroupVoice,

   157             hbTrId("txt_phone_setlabel_if_not_answered"),

   158             hbTrId("If not answered:"), true,

   159             m_helper,

   160             m_csVoiceCallPage);

   161     

   162     addDivertDataItem(m_DataItemIfNotAnswered, m_csVoiceCallPage);

   163     m_DataItemIfNotAnswered->setContentWidgetData("timeoutText", hbTrId("txt_phone_setlabel_delay"));

   164 

   165     m_DataItemIfOutOfReach = new CpDivertItemData(

   166             DivertConditionNotReachable,

   167             ServiceGroupVoice,

   168             hbTrId("txt_phone_setlabel_if_out_of_reach"),

   169             hbTrId("If out of reach:"), false,

   170             m_helper,

   171             m_csVoiceCallPage);

   172     

   173     addDivertDataItem(m_DataItemIfOutOfReach, m_csVoiceCallPage);

   174 

   175     m_DataItemIfNotAvailable = new CpDivertItemData(

   176             DivertConditionAllConditionalCases,

   177             ServiceGroupVoice,

   178             hbTrId("txt_phone_setlabel_if_not_available"),

   179             hbTrId("If not available:"), true,

   180             m_helper,

   181             m_csVoiceCallPage);

   182     

   183     addDivertDataItem(m_DataItemIfNotAvailable, m_csVoiceCallPage);

   184     DPRINT << ": OUT";

   185 }

   186 

   187 /*!

   188  CpDivertPluginGroup::createVideoCallItems

   189  */

   190 void CpDivertPluginGroup::createVideoCallItems()

   191 {

   192     DPRINT << ": IN";

   193     appendChild( new CpSettingFormItemData(

   194         HbDataFormModelItem::GroupPageItem,

   195         hbTrId("txt_phone_setlabel_service_val_video_divert")) );

   196     DPRINT << ": OUT";

   197 }

   198 

   199 /*!

   200  CpDivertPluginGroup::createVoIPCallItems

   201  */

   202 void CpDivertPluginGroup::createVoIPCallItems()

   203 {

   204     DPRINT << ": IN";

   205     appendChild( new CpSettingFormItemData(

   206         HbDataFormModelItem::GroupPageItem,

   207         hbTrId("VoIP")) );

   208     DPRINT << ": OUT";

   209 }

   210 

   211 /*!

   212   CpDivertPluginGroup::itemShown.

   213  */

   214 void CpDivertPluginGroup::itemShown(const QModelIndex& item)

   215 {

   216     DPRINT << ": IN";

   217     DPRINT << "item:" << item;

   218     HbDataFormModelItem* modelItem = 

   219             qobject_cast<HbDataFormModel*>(model())->itemFromIndex(item);

   220     

   221     if (!modelItem->contentWidgetData("number").isValid()) {

   222         if (modelItem==m_DataItemAllVoiceCalls) {

   223             addToDivertingRequestQueue(CheckDivertStatus, *m_DataItemAllVoiceCalls);

   224         } else if (modelItem==m_DataItemIfBusy) {

   225             addToDivertingRequestQueue(CheckDivertStatus, *m_DataItemIfBusy);

   226         } else if (modelItem==m_DataItemIfNotAnswered) {

   227             addToDivertingRequestQueue(CheckDivertStatus, *m_DataItemIfNotAnswered);

   228         } else if (modelItem==m_DataItemIfOutOfReach) {

   229             addToDivertingRequestQueue(CheckDivertStatus, *m_DataItemIfOutOfReach);

   230         } // do not update m_DataItemIfNotAvailable

   231     }

   232 

   233 

   234     DPRINT << ": OUT";

   235 }

   236 

   237 /*!

   238   CpDivertPluginGroup::addDivertDataItem.

   239  */

   240 void CpDivertPluginGroup::addDivertDataItem(

   241         CpDivertItemData *item, CpSettingFormItemData *parent)

   242 {

   243     parent->appendChild(item);

   244     QObject::connect(

   245         item, SIGNAL(itemClicked(CpDivertItemData&)),

   246         this, SLOT(changeDivertingStateRequested(CpDivertItemData&)));

   247 }

   248 

   249 /*!

   250   CpDivertPluginGroup::addToDivertingRequestQueue.

   251  */

   252 void CpDivertPluginGroup::addToDivertingRequestQueue(

   253         DivertRequest request, CpDivertItemData &item)

   254 {

   255     DPRINT << ": IN";

   256     CpDivertRequestQueueItem i;

   257     i.request = request;

   258     i.item = &item;

   259     m_divertRequestQueue.enqueue(i);

   260 

   261     if (m_divertRequestQueue.count()==1) {

   262        // Process if first item was added, process other later

   263         try {

   264             processDivertingRequestQueue();

   265         } catch(...) {

   266             DPRINT << "error!!";

   267         }

   268     }

   269 

   270 

   271     DPRINT << ": OUT";

   272 }

   273 

   274 /*!

   275   CpDivertPluginGroup::divertRequestProcessed.

   276  */

   277 void CpDivertPluginGroup::divertRequestProcessed()

   278 {

   279     DPRINT << ": IN";

   280     // Remove previous request and process next one

   281     if (!m_divertRequestQueue.isEmpty()) {

   282         m_divertRequestQueue.dequeue();

   283         processDivertingRequestQueue();

   284     }

   285 

   286     if (m_divertRequestQueue.isEmpty()) {

   287         // Queue empty so cancel process note

   288         CpPhoneNotes::instance()->cancelNote(m_activeProgressNoteId);

   289     }

   290     

   291     DPRINT << ": OUT";

   292 }

   293 

   294 /*!

   295   CpDivertPluginGroup::changeItemData.

   296  */

   297 void CpDivertPluginGroup::changeItemData(

   298         PsCallDivertingCondition condition, PsCallDivertingStatus status,

   299         const QString& number, int timeout)

   300 {

   301     DPRINT << ": IN";

   302     

   303     CpDivertSelectionCustomitem::State itemState = 

   304         CpDivertSelectionCustomitem::Disabled;

   305     if (status == DivertingStatusActive) {

   306         itemState = CpDivertSelectionCustomitem::Enabled;

   307     } else if (status == DivertingStatusInactive) {

   308         itemState = CpDivertSelectionCustomitem::Deactivated;

   309     } else {

   310         itemState = CpDivertSelectionCustomitem::Disabled;

   311     }

   312     

   313     switch (condition) {

   314     case DivertConditionUnconditional:

   315         m_DataItemAllVoiceCalls->setContentWidgetData("number", number);

   316         m_DataItemAllVoiceCalls->setContentWidgetData("timeout", timeout);

   317         m_DataItemAllVoiceCalls->setContentWidgetData("state", itemState);

   318         break;

   319     case DivertConditionBusy:

   320         m_DataItemIfBusy->setContentWidgetData("number", number);

   321         m_DataItemIfBusy->setContentWidgetData("timeout", timeout);

   322         m_DataItemIfBusy->setContentWidgetData("state", itemState);

   323         break;

   324     case DivertConditionNoReply:

   325         m_DataItemIfNotAnswered->setContentWidgetData("number", number);

   326         m_DataItemIfNotAnswered->setContentWidgetData("timeout", timeout);

   327         m_DataItemIfNotAnswered->setContentWidgetData("state", itemState);

   328         break;

   329     case DivertConditionNotReachable:

   330         m_DataItemIfOutOfReach->setContentWidgetData("number", number);

   331         m_DataItemIfOutOfReach->setContentWidgetData("timeout", timeout);

   332         m_DataItemIfOutOfReach->setContentWidgetData("state", itemState);

   333         break;

   334     case DivertConditionAllConditionalCases:

   335         DPRINT << ": DivertConditionAllConditionalCases";

   336         

   337         m_DataItemIfNotAvailable->setContentWidgetData("number", number);

   338         m_DataItemIfNotAvailable->setContentWidgetData("timeout", timeout);

   339         m_DataItemIfNotAvailable->setContentWidgetData("state", itemState);

   340         

   341         // If not available effects also conditions below

   342         m_DataItemIfBusy->setContentWidgetData("number", number);

   343         m_DataItemIfBusy->setContentWidgetData("timeout", timeout);

   344         m_DataItemIfBusy->setContentWidgetData("state", itemState);

   345         m_DataItemIfNotAnswered->setContentWidgetData("number", number);

   346         m_DataItemIfNotAnswered->setContentWidgetData("timeout", timeout);

   347         m_DataItemIfNotAnswered->setContentWidgetData("state", itemState);

   348         m_DataItemIfOutOfReach->setContentWidgetData("number", number);

   349         m_DataItemIfOutOfReach->setContentWidgetData("timeout", timeout);

   350         m_DataItemIfOutOfReach->setContentWidgetData("state", itemState);

   351         break;

   352     case DivertConditionAllCalls:

   353     case DivertConditionUnknown:

   354     default:

   355         break;

   356     }

   357 }

   358 

   359 /*!

   360   CpDivertPluginGroup::revertItemData.

   361  */

   362 void CpDivertPluginGroup::revertItemData(PsCallDivertingCondition condition)

   363 {

   364     DPRINT << ": IN";

   365     

   366     switch (condition) {

   367         case DivertConditionUnconditional:

   368             m_DataItemAllVoiceCalls->setContentWidgetData("state", 

   369                 m_DataItemAllVoiceCalls->contentWidgetData("state"));

   370             break;

   371         case DivertConditionBusy:

   372             m_DataItemIfBusy->setContentWidgetData("state", 

   373                 m_DataItemIfBusy->contentWidgetData("state"));

   374             break;

   375         case DivertConditionNoReply:

   376             m_DataItemIfNotAnswered->setContentWidgetData("state", 

   377                 m_DataItemIfNotAnswered->contentWidgetData("state"));

   378             break;

   379         case DivertConditionNotReachable:

   380             m_DataItemIfOutOfReach->setContentWidgetData("state", 

   381                 m_DataItemIfOutOfReach->contentWidgetData("state"));

   382             break;

   383         case DivertConditionAllConditionalCases:

   384             DPRINT << ": DivertConditionAllConditionalCases";

   385             m_DataItemIfNotAvailable->setContentWidgetData("state", 

   386                 m_DataItemIfNotAvailable->contentWidgetData("state"));

   387             break;

   388         case DivertConditionAllCalls:

   389         case DivertConditionUnknown:

   390         default:

   391             break;

   392     }

   393 }

   394 

   395 /*!

   396   CpDivertPluginGroup::processDivertingRequestQueue.

   397  */

   398 void CpDivertPluginGroup::processDivertingRequestQueue()

   399 {

   400     DPRINT << ": IN";

   401     if (m_divertRequestQueue.isEmpty()) {

   402         DPRINT << "queue empty : OUT";

   403         return;

   404     }

   405     CpDivertRequestQueueItem request = m_divertRequestQueue.head();

   406     // Command param

   407     PSCallDivertingCommand divertCommand;

   408     divertCommand.iServiceGroup = request.item->service();

   409     divertCommand.iCondition = request.item->condition();

   410     divertCommand.iStatus = DivertingStatusUnknown;

   411     divertCommand.iNumber = hbTrId("");

   412     divertCommand.iNoReplyTimer = 0;

   413 

   414     switch (request.request) {

   415         case ActivateDivert: {

   416             DPRINT << "activate";

   417             divertCommand.iSetting = RegisterDiverting;

   418             if (popUpVoiceNumberListQuery(

   419                     request.item->queryLabel(), divertCommand.iNumber)) {

   420                 if (request.item->needTimeoutInfo()) {

   421                     if (popUpTimerQuery(divertCommand.iNoReplyTimer)) {

   422                         setCallDiverting(divertCommand);

   423                     } else {

   424                         // Query was cancelled

   425                         request.item->setContentWidgetData("number", 

   426                                 request.item->contentWidgetData("number").toString());

   427                         request.item->setContentWidgetData("timeout", 

   428                                 request.item->contentWidgetData("timeout").toInt());

   429                         m_divertRequestQueue.clear();

   430                     }

   431                 } else {

   432                     setCallDiverting(divertCommand);

   433                 }

   434             } else {

   435                 // Query was cancelled

   436                 request.item->setContentWidgetData("number", 

   437                         request.item->contentWidgetData("number").toString());

   438                 request.item->setContentWidgetData("timeout", 

   439                         request.item->contentWidgetData("timeout").toInt());

   440                 m_divertRequestQueue.clear();

   441             }

   442         }

   443             break;

   444         case DeactivateDivert: {

   445             DPRINT << "deactivate";

   446             divertCommand.iSetting = EraseDiverting;

   447             setCallDiverting(divertCommand);

   448         }

   449             break;

   450         case CheckDivertStatus: {

   451             DPRINT << "check status";

   452             m_callDivertingWrapper->getCallDivertingStatus(

   453                 divertCommand.iServiceGroup,

   454                 divertCommand.iCondition,

   455                 bscParam() );

   456             

   457             if (!CpPhoneNotes::instance()->noteShowing()) {

   458                 CpPhoneNotes::instance()->showGlobalProgressNote(

   459                         m_activeProgressNoteId, hbTrId("Requesting"));

   460             }

   461         }

   462             break;

   463         default:

   464             DPRINT << "Error: unknown enum value";

   465             break;

   466     }

   467 

   468     DPRINT << ": OUT";

   469 }

   470 

   471 /*!

   472   CpDivertPluginGroup::changeDivertingStateRequested.

   473  */

   474 void CpDivertPluginGroup::changeDivertingStateRequested(

   475         CpDivertItemData &item)

   476 {

   477     DPRINT << ": IN";

   478     

   479     DivertRequest event=ActivateDivert;

   480     if (CpDivertSelectionCustomitem::Enabled == 

   481             item.contentWidgetData("state").toInt()) {

   482         event = DeactivateDivert;

   483     } else {

   484         event = ActivateDivert;

   485     }

   486     

   487     addToDivertingRequestQueue(event, item);

   488     DPRINT << ": OUT";

   489 }

   490 

   491 /*!

   492   CpDivertPluginGroup::handleDivertingChanged.

   493  */

   494 void CpDivertPluginGroup::handleDivertingChanged(

   495         const PSCallDivertingCommand& aSetting, 

   496         bool aPlural)

   497 {

   498     DPRINT << ": IN";

   499     

   500     CpPhoneNotes::instance()->cancelNote(m_activeNoteId);

   501     DPRINT << "aPlural:" << aPlural;

   502     DPRINT << "iCondition:" << aSetting.iCondition;

   503     DPRINT << "iNoReplyTimer:" << aSetting.iNoReplyTimer;

   504     DPRINT << "iNumber:" << aSetting.iNumber;

   505     DPRINT << "iServiceGroup:" << aSetting.iServiceGroup;

   506     DPRINT << "iSetting:" << aSetting.iSetting;

   507     DPRINT << "iStatus:" << aSetting.iStatus;

   508 

   509     changeItemData(

   510         aSetting.iCondition, aSetting.iStatus,

   511         aSetting.iNumber, aSetting.iNoReplyTimer);

   512     

   513     updateDependentDivertOptions();

   514     

   515     switch(aSetting.iStatus) {

   516         case DivertingStatusActive:

   517             if (aPlural) {

   518                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,

   519                     hbTrId("Diverts activated"), 

   520                     HbMessageBox::MessageTypeInformation);

   521             } else {

   522                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,

   523                     hbTrId("Divert activated"), 

   524                     HbMessageBox::MessageTypeInformation);

   525             }

   526             if (!m_divertToVoiceMailBox) {

   527                 // Number, except vmbx number, will be added to defaultnumber list

   528                 m_callDivertingWrapper->setNewDefaultNumber(aSetting.iNumber);

   529             }

   530             // Diverting calls does not affect Internet calls

   531             if (Tools::voipSupported() &&

   532                     aSetting.iServiceGroup == ServiceGroupVoice) {

   533                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,

   534                     hbTrId("Diverting calls does not affect Internet calls"), 

   535                     HbMessageBox::MessageTypeInformation);

   536             }

   537             break;

   538         case DivertingStatusNotRegistered:

   539         case DivertingStatusInactive:

   540             if (aPlural) {

   541                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,

   542                     hbTrId("Diverts cancelled"), 

   543                     HbMessageBox::MessageTypeInformation);

   544             } else {

   545                 CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,

   546                     hbTrId("Divert cancelled"), 

   547                     HbMessageBox::MessageTypeInformation);

   548             }

   549             break;

   550         case DivertingStatusNotProvisioned:

   551         case DivertingStatusUnknown:

   552         default:

   553             CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId,

   554                 hbTrId("Not done"), 

   555                 HbMessageBox::MessageTypeInformation);

   556     }

   557     

   558     if ((DivertConditionUnconditional == aSetting.iCondition) &&

   559             (DivertingStatusActive != aSetting.iStatus)) {

   560         // Must query data for diverts depending on all calls divert, because 

   561         // data may have been lost for registered diverts, which were 

   562         // automatically deactivated due to the activation of all calls divert.

   563         if (CpDivertSelectionCustomitem::Deactivated == 

   564                 m_DataItemIfBusy->contentWidgetData("state").toInt()) {

   565             addToDivertingRequestQueue(

   566                 CheckDivertStatus, *m_DataItemIfBusy);

   567         }

   568         

   569         if (CpDivertSelectionCustomitem::Deactivated == 

   570                 m_DataItemIfNotAnswered->contentWidgetData("state").toInt()) {

   571             addToDivertingRequestQueue(

   572                 CheckDivertStatus, *m_DataItemIfNotAnswered);

   573         }

   574         

   575         if (CpDivertSelectionCustomitem::Deactivated == 

   576                 m_DataItemIfOutOfReach->contentWidgetData("state").toInt()) {

   577             addToDivertingRequestQueue(

   578                 CheckDivertStatus, *m_DataItemIfOutOfReach);

   579         }

   580     }

   581     

   582     DPRINT << ": OUT";

   583 }

   584    

   585 /*!

   586   CpDivertPluginGroup::handleDivertingStatus.

   587  */

   588 void CpDivertPluginGroup::handleDivertingStatus(

   589         QList<PSCallDivertingStatus*> &divertList, 

   590         bool plural)

   591 {

   592     DPRINT << ": IN";

   593     DPRINT << "divertList.Size():" << divertList.size();

   594     DPRINT << "plural:" << plural;

   595 

   596     foreach(PSCallDivertingStatus* status, divertList) {

   597         DPRINT << status->iCondition;

   598         DPRINT << status->iNumber;

   599         DPRINT << status->iServiceGroup;

   600         DPRINT << status->iStatus;

   601         DPRINT << status->iTimeout;

   602         changeItemData(

   603             status->iCondition, status->iStatus, 

   604             status->iNumber, status->iTimeout);

   605     }

   606     

   607     updateDependentDivertOptions();

   608     

   609     DPRINT << ": OUT";

   610 }

   611 

   612 /*!

   613   CpDivertPluginGroup::handleDivertingError.

   614  */

   615 void CpDivertPluginGroup::handleDivertingError(int aReason)

   616 {

   617     DPRINT << ": IN : aReason:" << aReason;

   618     

   619     // Update view item for failed request

   620     revertItemData(m_divertRequestQueue.head().item->condition());

   621     

   622     // Clear queue

   623     m_divertRequestQueue.clear();

   624     

   625     // Cancel previous note

   626     CpPhoneNotes::instance()->cancelNote(m_activeNoteId);

   627     

   628     // Show error note

   629     CpPhoneNotes::instance()->showGlobalErrorNote(m_activeNoteId, aReason);

   630     

   631     DPRINT << ": OUT";

   632 }

   633 

   634 /*!

   635   CpDivertPluginGroup::popUpVoiceNumberListQuery.

   636  */

   637 bool CpDivertPluginGroup::popUpVoiceNumberListQuery(

   638         const QString& heading, QString& result)

   639 {

   640     DPRINT << ": IN";

   641     

   642     bool requestOK(false);

   643     m_divertToVoiceMailBox = false;

   644     QStringList defNumbers;

   645     HbDialog *dialog = createDialog(heading);

   646     HbListWidget *list = new HbListWidget(dialog);

   647     addItemToListWidget(

   648         list, hbTrId("txt_phone_setlabel_voice_mbx"), hbTrId("txt_phone_setlabel_voice_mbx") );

   649     // Add "old" divert number to list

   650     m_callDivertingWrapper->getDefaultNumbers(defNumbers);

   651     int count(defNumbers.count());

   652     for (int i = 0; i < count; i++) {

   653         addItemToListWidget(list, defNumbers[i], defNumbers[i]);

   654     }

   655     addItemToListWidget(list, hbTrId("Other number"), hbTrId("Other number") );

   656     // Connect list item activation signal to close the popup

   657     connect(

   658         list, SIGNAL(activated(HbListWidgetItem*)), 

   659         dialog, SLOT(close()));

   660     // Sets the "Cancel"-action/button

   661     HbAction *cancelAction = new HbAction("Cancel");

   662     dialog->setPrimaryAction(cancelAction);

   663     dialog->setContentWidget(list);

   664     // Launch popup and handle the response

   665     if (dialog->exec() != cancelAction) {

   666         // Update the view with selected text

   667         QString data = list->currentItem()->data().toString();

   668         if (data == hbTrId("txt_phone_setlabel_voice_mbx")) {

   669             m_callDivertingWrapper->getVoiceMailBoxNumber(result);

   670             if (result.size()) {

   671                 // voicemailboxnumber found

   672                 m_divertToVoiceMailBox = true;

   673                 requestOK = true;

   674             }

   675         } else if (data == hbTrId("Other number")) {

   676             requestOK = popUpNumberEditor(hbTrId("Number:"), result);

   677         } else {

   678             //TODO if matched contact name not work

   679             result = data;

   680             requestOK = true;

   681         }

   682     }

   683     else {

   684         DPRINT << ": Cancel";

   685     }

   686     disconnect(

   687         list, SIGNAL(activated(HbListWidgetItem*)), 

   688         dialog, SLOT(close()));

   689     delete dialog;

   690     

   691     DPRINT << ": OUT : requestOK :" << requestOK;

   692     return requestOK;

   693 }

   694 

   695 /*!

   696   CpDivertPluginGroup::popUpNumberEditor.

   697  */

   698 bool CpDivertPluginGroup::popUpNumberEditor(

   699         const QString& heading, QString& result)

   700 {

   701     DPRINT << ": IN";

   702 

   703     bool requestOK(false);

   704     HbDialog *dialog = createDialog(heading);

   705     HbLineEdit *editor = new HbLineEdit(dialog);

   706     HbEditorInterface editorInterface(editor);

   707     editorInterface.setUpAsPhoneNumberEditor();

   708     dialog->setContentWidget(editor);

   709     HbAction *okAction = new HbAction(hbTrId("OK"));

   710     dialog->addAction(okAction);

   711     HbAction *cancelAction = new HbAction(hbTrId("Cancel"));

   712     dialog->setSecondaryAction(cancelAction);

   713     

   714     HbAction *resultAction = dialog->exec();

   715     if (resultAction == cancelAction) {

   716         DPRINT << ": canceled";

   717     }

   718     else {

   719         result = editor->text();

   720         DPRINT << ": number "

   721             << result;

   722         if (result.count()) {

   723             requestOK = true;

   724         }

   725         else {

   726             CpPhoneNotes::instance()->showGlobalNote(m_activeNoteId, 

   727                 hbTrId("Enter number"), HbMessageBox::MessageTypeWarning);

   728         }

   729     }

   730     delete dialog;

   731     

   732     DPRINT << ": OUT : requestOK :" << requestOK;

   733     return requestOK;

   734 }

   735 

   736 /*!

   737   CpDivertPluginGroup::setCallDiverting.

   738  */

   739 void CpDivertPluginGroup::setCallDiverting(PSCallDivertingCommand& command)

   740 {

   741     DPRINT << ": IN";

   742     DPRINT << "iCondition:" << command.iCondition;

   743     DPRINT << "iNoReplyTimer:" << command.iNoReplyTimer;

   744     DPRINT << "iNumber:" << command.iNumber;

   745     DPRINT << "iServiceGroup:" << command.iServiceGroup;

   746     DPRINT << "iSetting:" << command.iSetting;

   747     DPRINT << "iStatus:" << command.iStatus;

   748     

   749     int result = m_callDivertingWrapper->setCallDiverting(command, bscParam());

   750     if (0 == result) {

   751         if (!CpPhoneNotes::instance()->noteShowing()) {

   752             CpPhoneNotes::instance()->showGlobalProgressNote(

   753                     m_activeProgressNoteId, hbTrId("Requesting"));

   754         }

   755     } else {

   756         handleDivertingError(result);

   757     }

   758     

   759     DPRINT << ": OUT ";

   760 }

   761 

   762 /*!

   763   CpDivertPluginGroup::popUpTimerQuery.

   764  */

   765 bool CpDivertPluginGroup::popUpTimerQuery(int &timeout) const

   766 {

   767     DPRINT << ": IN";

   768     

   769     bool requestOK(false);

   770     HbDialog *dialog = createDialog(hbTrId("Time out"));

   771     HbListWidget *list = new HbListWidget(dialog);

   772     addItemToListWidget(list, hbTrId("5 second"), 5 );

   773     addItemToListWidget(list, hbTrId("10 second"), 10);

   774     addItemToListWidget(list, hbTrId("15 second"), 15);

   775     addItemToListWidget(list, hbTrId("20 second"), 20);

   776     addItemToListWidget(list, hbTrId("25 second"), 25);

   777     addItemToListWidget(list, hbTrId("30 second"), 30);

   778     // Connect list item activation signal to close the popup

   779     connect(

   780         list, SIGNAL(activated(HbListWidgetItem*)), 

   781         dialog, SLOT(close()));

   782     // Sets the "Cancel"-action/button

   783     HbAction *cancelAction = new HbAction(hbTrId("Cancel"));

   784     dialog->setPrimaryAction(cancelAction);

   785     dialog->setContentWidget(list);

   786     // Launch popup and handle the response

   787     if (dialog->exec() != cancelAction) {

   788         // Update the view with selected text

   789         if (list->currentItem()) {

   790             timeout = list->currentItem()->data().toInt();

   791         }

   792         requestOK = true;

   793     }

   794     else {

   795         DPRINT << ": Cancel";

   796     }

   797 

   798     disconnect(

   799         list, SIGNAL(activated(HbListWidgetItem*)), 

   800         dialog, SLOT(close()));

   801     delete dialog;

   802     

   803     DPRINT << ": OUT : requestOK :" << requestOK;

   804     return requestOK;

   805 }

   806 

   807 /*!

   808   CpDivertPluginGroup::setbscParam.

   809  */

   810 int CpDivertPluginGroup::bscParam()

   811 {

   812     DPRINT << ": IN";

   813 

   814     int bsc = AllTeleAndBearer;

   815     int alsLine(AlsNotSupported);

   816     m_ssSettingsWrapper->get(Als,alsLine);

   817     DPRINT << ": alsLine " << alsLine;

   818     if ((alsLine == AlsNotSupported) || (alsLine == AlsPrimary)) {

   819         // Etelephony only activates voice service nothing else or causes

   820         // voice service status request.

   821         bsc = Telephony;

   822     }

   823     else { // ESSSettingsAlsAlternate

   824         // EAltTele only activates alternate service nothing else or causes

   825         // alternate service status request.

   826         bsc = AltTele;

   827     }

   828     

   829     DPRINT << ": OUT : bsc :" << bsc;

   830     return bsc;

   831 }

   832 

   833 /*!

   834   CpDivertPluginGroup::createDialog.

   835  */

   836 HbDialog* CpDivertPluginGroup::createDialog( const QString& heading ) const

   837 {

   838     DPRINT << ": IN";

   839  

   840     HbDialog *dialog = new HbDialog();

   841     dialog->setDismissPolicy(HbDialog::NoDismiss);

   842     dialog->setTimeout(HbDialog::NoTimeout);

   843     dialog->setHeadingWidget(new HbLabel(heading));

   844     

   845     DPRINT << ": OUT";

   846     return dialog;

   847 }

   848 

   849 /*!

   850   CpDivertPluginGroup::addItemToListWidget.

   851  */

   852 void CpDivertPluginGroup::addItemToListWidget(HbListWidget* w,

   853         const QString& item, const QString& data) const

   854 {

   855     DPRINT << ": IN";

   856  

   857     HbListWidgetItem* o = new HbListWidgetItem();

   858     o->setText(item);

   859     o->setData(data);

   860     w->addItem(o);

   861     

   862     DPRINT << ": OUT";

   863 }

   864 

   865 /*!

   866   CpDivertPluginGroup::addItemToListWidget.

   867  */

   868 void CpDivertPluginGroup::addItemToListWidget(HbListWidget* w,

   869         const QString& item, const int& data) const

   870 {

   871     DPRINT << ": IN";

   872  

   873     HbListWidgetItem* o = new HbListWidgetItem();

   874     o->setText(item);

   875     o->setData(data);

   876     w->addItem(o);

   877     

   878     DPRINT << ": OUT";

   879 }

   880 

   881 /*!

   882   CpDivertPluginGroup::updateDependentDivertOptions.

   883   Updates statuses of diverts which are dependent from the status of some

   884   other divert. Logic for dependent changes are:

   885   1. Activation of all calls divert deactivates other diverts/puts them 

   886   into quiescent state.

   887   2. Deactivation of all calls divert enables diverts in quiescent state.

   888   3. Not available option is an abstraction of CFB, CFNry, CFNrc diverts.

   889      Enabling/disabling that options changes all the aforementioned diverts 

   890      at once.

   891 */

   892 void CpDivertPluginGroup::updateDependentDivertOptions()

   893 {

   894     DPRINT << ": IN";

   895     

   896     // all calls divert activation deactivates automatically other diverts

   897     QVariant itemState = m_DataItemAllVoiceCalls->contentWidgetData("state");

   898     if ((itemState.isValid()) && 

   899         (itemState.toInt() == CpDivertSelectionCustomitem::Enabled)) {

   900         itemState = m_DataItemIfBusy->contentWidgetData("state");

   901         if ((itemState.isValid()) && 

   902             (itemState == CpDivertSelectionCustomitem::Enabled)) {

   903             m_DataItemIfBusy->setContentWidgetData(

   904                 "state", CpDivertSelectionCustomitem::Deactivated);

   905         }

   906         

   907         itemState = m_DataItemIfNotAnswered->contentWidgetData("state");

   908         if ((itemState.isValid()) &&

   909             (itemState == CpDivertSelectionCustomitem::Enabled)) {

   910             m_DataItemIfNotAnswered->setContentWidgetData(

   911                 "state", CpDivertSelectionCustomitem::Deactivated);

   912         }

   913         

   914         itemState = m_DataItemIfOutOfReach->contentWidgetData("state");

   915         if ((itemState.isValid()) &&

   916             (itemState == CpDivertSelectionCustomitem::Enabled)) {

   917             m_DataItemIfOutOfReach->setContentWidgetData(

   918                 "state", CpDivertSelectionCustomitem::Deactivated);

   919         }

   920     }

   921     

   922     // update not available divert option

   923     updateNotAvailableDivertOption();

   924     

   925     DPRINT << ": OUT";

   926 }

   927 

   928 /*!

   929   CpDivertPluginGroup::updateNotAvailableDivertOption.

   930  */

   931 void CpDivertPluginGroup::updateNotAvailableDivertOption()

   932 {

   933     DPRINT << ": IN";

   934     

   935     // We must check that both states & numbers match amongst CFB, CRNry and 

   936     // CFNrc before concluding that not available divert is enabled, because

   937     // some networks may not return divert number for inactive diverts.

   938     int cfbState = 

   939         m_DataItemIfBusy->contentWidgetData("state").toInt();

   940     int cfnryState = 

   941         m_DataItemIfNotAnswered->contentWidgetData("state").toInt();

   942     int cfnrcState = 

   943         m_DataItemIfOutOfReach->contentWidgetData("state").toInt();

   944     QVariant cfbNumber = 

   945         m_DataItemIfBusy->contentWidgetData("number");

   946     QVariant cfnryNumber = 

   947         m_DataItemIfNotAnswered->contentWidgetData("number");

   948     QVariant cfnrcNumber = 

   949         m_DataItemIfOutOfReach->contentWidgetData("number");

   950     

   951     if ((cfbNumber == cfnryNumber) && (cfbNumber == cfnrcNumber) &&

   952         (cfbState == cfnryState) && (cfbState == cfnrcState)) {

   953         m_DataItemIfNotAvailable->setContentWidgetData(

   954             "number", m_DataItemIfBusy->contentWidgetData("number"));

   955         m_DataItemIfNotAvailable->setContentWidgetData(

   956             "timeout", m_DataItemIfNotAnswered->contentWidgetData("timeout"));

   957         m_DataItemIfNotAvailable->setContentWidgetData(

   958             "state", m_DataItemIfBusy->contentWidgetData("state"));

   959     } else {

   960         m_DataItemIfNotAvailable->setContentWidgetData("number", "");

   961         m_DataItemIfNotAvailable->setContentWidgetData("timeout", 0);

   962         m_DataItemIfNotAvailable->setContentWidgetData(

   963             "state", CpDivertSelectionCustomitem::Disabled);

   964     }

   965     

   966     DPRINT << ": OUT";

   967 }

   968 

   969 // End of File.