1 /*

     2 * Copyright (c) 2007 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:  Implementation of the class CPbkxRclServiceUiContextImpl.

    15 *

    16 */

    17 

    18 

    19 #include "emailtrace.h"

    20 #include <pbkxrclengine.rsg>

    21 #include <cntfldst.h>

    22 #include <StringLoader.h>

    23 #include <CPbkContactEngine.h>

    24 #include <bautils.h>

    25 #include <textresolver.h>

    26 //<cmail>

    27 #include "fsccontactactionservicedefines.h"

    28 //</cmail>

    29 #include <data_caging_path_literals.hrh>

    30 #include <AknsUtils.h>

    31 #include <hlplch.h>

    32 

    33 #include "cpbkxrclserviceuicontextimpl.h"

    34 #include "pbkxremotecontactlookuppanic.h"

    35 #include "cpbkxremotecontactlookupprotocolsession.h"

    36 #include "cpbkxrclprotocolenvimpl.h"

    37 #include "cpbkxremotecontactlookupprotocoladapter.h"

    38 #include "cpbkxremotecontactlookupprotocolaccount.h"

    39 

    40 #include "cpbkxrclsearchresultdlg.h"

    41 #include "cpbkxrclresultinfodlg.h"

    42 #include "cpbkxrclqueryeditor.h"

    43 #include "cpbkxrclactionservicewrapper.h"

    44 

    45 #include "pbkxrclutils.h"

    46 #include "pbkxrclengineconstants.h"

    47 

    48 #include "engine.hrh"

    49 #include <aknnotewrappers.h>

    50 

    51 // own macro to handle errors in traps

    52 // <cmail> Do not use, produces Codescanner warnings

    53 //#define EXIT_IF_ERROR( xxx ) { TRAPD( err, xxx ); if ( err != KErrNone ) HandleError( err ); }

    54 // </cmail>

    55 

    56 /// Unnamed namespace for local definitions

    57 namespace {

    58 const TInt KTwoMinutesTimerInterval(120000000);

    59 } /// namespace

    60 

    61 // ======== MEMBER FUNCTIONS ========

    62 

    63 // ---------------------------------------------------------------------------

    64 // CPbkxRclServiceUiContextImpl::NewL

    65 // ---------------------------------------------------------------------------

    66 //

    67 CPbkxRclServiceUiContextImpl* CPbkxRclServiceUiContextImpl::NewL(

    68     TPbkxRemoteContactLookupProtocolAccountId aId,

    69     TMode aMode )

    70     {

    71     FUNC_LOG;

    72     CPbkxRclServiceUiContextImpl* context = 

    73         CPbkxRclServiceUiContextImpl::NewLC( aId, aMode );

    74     CleanupStack::Pop( context );

    75     return context;

    76     }

    77 

    78 // ---------------------------------------------------------------------------

    79 // CPbkxRclServiceUiContextImpl::NewLC

    80 // ---------------------------------------------------------------------------

    81 //

    82 CPbkxRclServiceUiContextImpl* CPbkxRclServiceUiContextImpl::NewLC(

    83     TPbkxRemoteContactLookupProtocolAccountId aId,

    84     TMode aMode )

    85     {

    86     FUNC_LOG;

    87     CPbkxRclServiceUiContextImpl* context = 

    88         new ( ELeave ) CPbkxRclServiceUiContextImpl( aId, aMode );

    89     CleanupStack::PushL( context );

    90     context->ConstructL();

    91     return context;

    92     }

    93 

    94 // ---------------------------------------------------------------------------

    95 // CPbkxRclServiceUiContextImpl::CPbkxRclServiceUiContextImpl

    96 // ---------------------------------------------------------------------------

    97 //

    98 CPbkxRclServiceUiContextImpl::CPbkxRclServiceUiContextImpl(

    99     TPbkxRemoteContactLookupProtocolAccountId aId,

   100     TMode aMode ) : 

   101     iAccountId( aId ), iMode( aMode ), iSelectedIndex( KErrNotFound )

   102     {

   103     FUNC_LOG;

   104     }

   105 

   106 // ---------------------------------------------------------------------------

   107 // CPbkxRclServiceUiContextImpl::~CPbkxRclServiceUiContextImpl

   108 // ---------------------------------------------------------------------------

   109 //

   110 CPbkxRclServiceUiContextImpl::~CPbkxRclServiceUiContextImpl()

   111     {

   112     FUNC_LOG;

   113 

   114     if( iTimer )

   115         {

   116         iTimer->Cancel();

   117         }

   118     delete iTimer;

   119 

   120     iQueryText.Close();

   121     iQueryCriteria.Close();

   122 

   123     CCoeEnv::Static()->DeleteResourceFile( iResourceFileOffset );

   124 

   125     iContactCards.Reset();

   126     iSearchResults.ResetAndDestroy();

   127     iWaitObjects.ResetAndDestroy();

   128     delete iContactEngine;

   129 

   130     delete iActionServiceWrapper;

   131 

   132     delete iAccount;

   133     delete iSession;

   134     delete iAdapter;

   135     delete iEnvImpl;

   136 

   137     delete iEventScheduler;

   138     

   139     }

   140 

   141 // ---------------------------------------------------------------------------

   142 // CPbkxRclServiceUiContextImpl::ConstructL

   143 // ---------------------------------------------------------------------------

   144 //

   145 void CPbkxRclServiceUiContextImpl::ConstructL()

   146     {

   147     FUNC_LOG;

   148 

   149     CCoeEnv* coeEnv = CCoeEnv::Static();

   150 

   151     TFileName dllFileName;

   152     Dll::FileName( dllFileName );

   153       

   154     TParse parse;

   155     parse.Set( KResourceFile, &KDC_APP_RESOURCE_DIR, &dllFileName );

   156     TFileName resourceFile = parse.FullName();

   157     BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );

   158 

   159     TRAPD( status,

   160            iResourceFileOffset = coeEnv->AddResourceFileL( resourceFile ) );

   161     

   162     if( status != KErrNone )

   163         {

   164     	PbkxRclPanic( EPbkxRclPanicGeneral );		

   165         }

   166 	else 

   167         {

   168         }

   169 

   170     // create default contact engine to use to create CPbkContactItems

   171     iContactEngine = CPbkContactEngine::NewL();

   172 

   173     // create actions service wrapper used by UI views

   174     iActionServiceWrapper = CPbkxRclActionServiceWrapper::NewL( *iContactEngine );

   175 

   176     iActionServiceWrapper->SetContactSelectorMode( 

   177         iMode == EModeContactSelector );

   178 

   179     // Create objects needed for executing the search

   180     iEnvImpl = CPbkxRclProtocolEnvImpl::NewL();

   181     

   182     iAdapter = CPbkxRemoteContactLookupProtocolAdapter::NewL( 

   183         iAccountId.iProtocolUid, 

   184         *iEnvImpl );

   185 

   186     iAccount = iAdapter->NewProtocolAccountL( iAccountId );

   187 

   188     if ( iAccount == NULL )

   189         {

   190         User::Leave( KErrNotFound );

   191         }

   192     

   193     iSession = iAdapter->NewSessionL();

   194     iSession->InitializeL( *this, iAccountId );

   195 

   196     iEventScheduler = CPbkxRclEventScheduler::NewL( *this );

   197     

   198     iTimer = CPeriodic::NewL( CActive::EPriorityIdle );

   199 

   200     }

   201 

   202 // ---------------------------------------------------------------------------

   203 // CPbkxRclServiceUiContextImpl::GetSelectedContactL

   204 // ---------------------------------------------------------------------------

   205 //

   206 CContactItem* CPbkxRclServiceUiContextImpl::GetSelectedContactL()

   207     {

   208     FUNC_LOG;

   209     __ASSERT_ALWAYS( iSelectedIndex >= 0 && iSelectedIndex < iContactCards.Count(),

   210                      PbkxRclPanic( EPbkxRclPanicGeneral ) );

   211     CContactCard* selected = iContactCards[iSelectedIndex];

   212     CContactCard* copy = CContactCard::NewL( selected );

   213     return copy;

   214     }

   215 

   216 // ---------------------------------------------------------------------------

   217 // CPbkxRclServiceUiContextImpl::GetResultByIndex

   218 // ---------------------------------------------------------------------------

   219 //

   220 CPbkxRemoteContactLookupProtocolResult* 

   221 CPbkxRclServiceUiContextImpl::GetResultByIndex( TInt aIndex )

   222     {

   223     __ASSERT_ALWAYS( aIndex >= 0 && aIndex < iContactCards.Count(), 

   224                      PbkxRclPanic( EPbkxRclPanicGeneral ) );

   225   

   226     CContactCard* card = iContactCards[aIndex];

   227     CPbkxRemoteContactLookupProtocolResult* result = NULL;

   228     for ( TInt i = 0; i < iSearchResults.Count(); i++ )

   229         {

   230         if ( card == &( iSearchResults[i]->ContactItem() ) )

   231             {

   232             result = iSearchResults[i];

   233             break;

   234             }

   235         }

   236 

   237     __ASSERT_ALWAYS( result != NULL, PbkxRclPanic( EPbkxRclPanicGeneral ) );

   238 

   239     return result;

   240     }

   241 

   242 // ---------------------------------------------------------------------------

   243 // CPbkxRclServiceUiContextImpl::ExecuteL

   244 // ---------------------------------------------------------------------------

   245 //

   246 void CPbkxRclServiceUiContextImpl::ExecuteL( const TDesC& aQueryText, TResult& aResult )

   247     {

   248     FUNC_LOG;

   249 

   250     // set state as initial

   251     ResetState();

   252     SetState( EInitial );

   253     iExitCode = KErrNone;

   254 

   255     iSearchResults.ResetAndDestroy();

   256 

   257     iQueryCriteria.Close();

   258     iQueryCriteria.CreateL( KRclQueryTextMaxLength );

   259     iQueryCriteria = aQueryText.Left( KRclQueryTextMaxLength );

   260 

   261     iResult = &aResult;

   262 

   263     TOperation op = ( iMode != EModeExistingCriteria ) ? 

   264         EOpenSearchQueryDefault : EExecuteSearchWithNoQuery;

   265     

   266     AddOperation( op );

   267         

   268     StartActiveWaitL( EMainWait );

   269 

   270     

   271     HandleContextExitL();

   272 

   273     }

   274 

   275 // ---------------------------------------------------------------------------

   276 // CPbkxRclServiceUiContextImpl::LooseSearchCompleted

   277 // ---------------------------------------------------------------------------

   278 //

   279 void CPbkxRclServiceUiContextImpl::LooseSearchCompleted(

   280     TInt aStatus,

   281     RPointerArray<CPbkxRemoteContactLookupProtocolResult>& aResults )

   282     {

   283     FUNC_LOG;

   284 

   285     // <cmail>

   286     TRAPD( err, DoLooseSearchCompletedL( aStatus, aResults ) );

   287     if ( err != KErrNone )

   288         {

   289         HandleError( err );

   290         }

   291     // </cmail>

   292     

   293     }

   294 

   295 // ---------------------------------------------------------------------------

   296 // CPbkxRclServiceUiContextImpl::ContactFieldsRetrievalCompleted

   297 // ---------------------------------------------------------------------------

   298 //

   299 void CPbkxRclServiceUiContextImpl::ContactFieldsRetrievalCompleted( TInt aStatus )

   300     {

   301     FUNC_LOG;

   302 

   303     // <cmail>

   304     TRAPD( err, DoContactFieldsRetrievalCompletedL( aStatus ) );

   305     if ( err != KErrNone )

   306         {

   307         HandleError( err );

   308         }

   309     // </cmail>

   310 

   311     }

   312 

   313 // ---------------------------------------------------------------------------

   314 // CPbkxRclServiceUiContextImpl::RetrieveDetailsL

   315 // ---------------------------------------------------------------------------

   316 //

   317 CContactCard* CPbkxRclServiceUiContextImpl::RetrieveDetailsL( 

   318     TInt aContactIndex,

   319     const TDesC& aWaitNoteText )

   320     {

   321     FUNC_LOG;

   322 

   323     CPbkxRemoteContactLookupProtocolResult* result = GetResultByIndex( aContactIndex );

   324 

   325     CContactCard* card = static_cast<CContactCard*>( &result->ContactItem() );

   326 

   327     if ( !result->IsComplete() )

   328         {

   329         

   330         RPointerArray<CPbkxRemoteContactLookupProtocolResult> array;

   331         CleanupClosePushL( array );

   332         array.AppendL( result );

   333 

   334         iSession->RetrieveContactFieldsL( array );

   335 

   336         // Start time for time out event

   337         iTimer->Start(

   338         		KTwoMinutesTimerInterval, KTwoMinutesTimerInterval, 

   339             TCallBack(TimerCallBack, this));

   340         

   341         DisplayWaitDialogL( R_RCL_SEARCH_WAIT_DIALOG_CANCEL, aWaitNoteText );

   342 

   343         // Start active wait. When contact retrieval is completed, 

   344         // ContactFieldsRetrievalCompleted is called. If user cancels

   345         // retrieval, DialogDismissedL is called. TimeOut is called when time is out.

   346         StartActiveWaitL( EContactRetrievalWait );

   347         

   348         CleanupStack::PopAndDestroy( &array );

   349         

   350 

   351         // if contact retrieval was canceledor retrieval failed, 

   352         // result is not yet complete

   353         if ( !result->IsComplete() )

   354             {

   355             card = NULL;

   356             }

   357         

   358         }

   359 

   360     return card;

   361     }

   362 

   363 // ---------------------------------------------------------------------------

   364 // CPbkxRclServiceUiContextImpl::ContactCount

   365 // ---------------------------------------------------------------------------

   366 //

   367 TInt CPbkxRclServiceUiContextImpl::ContactCount() const

   368     {

   369     FUNC_LOG;

   370     return iContactCards.Count();

   371     }

   372 

   373 // ---------------------------------------------------------------------------

   374 // CPbkxRclServiceUiContextImpl::SetSelectedContact

   375 // ---------------------------------------------------------------------------

   376 //

   377 void CPbkxRclServiceUiContextImpl::SetSelectedContactL( TInt aIndex )

   378     {

   379     FUNC_LOG;

   380     iSearchResultDialog->SetCurrentItemIndexL( aIndex );

   381     }

   382 

   383 // ---------------------------------------------------------------------------

   384 // CPbkxRclServiceUiContextImpl::EventTriggered

   385 // ---------------------------------------------------------------------------

   386 //

   387 void CPbkxRclServiceUiContextImpl::EventTriggered()

   388     {

   389     FUNC_LOG;

   390 

   391     // <cmail>

   392     TRAPD( err, DoHandleOperationL() );

   393     if ( err != KErrNone )

   394         {

   395         HandleError( err );

   396         }

   397     // </cmail>

   398 

   399     }

   400 

   401 // ---------------------------------------------------------------------------

   402 // CPbkxRclServiceUiContextImpl::ProcessCommandL

   403 // ---------------------------------------------------------------------------

   404 //

   405 void CPbkxRclServiceUiContextImpl::ProcessCommandL( TInt aCommandId )

   406     {

   407     FUNC_LOG;

   408    

   409     // some commands are handled the same way no matter which dialog is on top

   410     TBool handled = ETrue;

   411 

   412     switch ( aCommandId )

   413         {

   414         case ERclCmdVoiceCall:

   415             iActionServiceWrapper->ExecuteActionL( 

   416                 KFscAtComCallGSM );

   417             break;

   418         case ERclCmdVideoCall:

   419             iActionServiceWrapper->ExecuteActionL( 

   420                 KFscAtComCallVideo );

   421             break;

   422         case ERclCmdVoip:

   423             iActionServiceWrapper->ExecuteActionL(

   424                 KFscAtComCallVoip );

   425             break;

   426         case ERclCmdSendMsg:

   427             iActionServiceWrapper->ExecuteActionL( 

   428                 KFscAtComSendMsg );

   429             break;

   430           

   431         case ERclCmdSendEmail:

   432             iActionServiceWrapper->ExecuteActionL( 

   433                 KFscAtComSendEmail );

   434             break;

   435             

   436         case ERclCmdSendMeetingReq:

   437             iActionServiceWrapper->ExecuteActionL( 

   438                 KFscAtComSendCalReq );

   439             break;

   440         case ERclCmdSendAudioMsg:

   441             iActionServiceWrapper->ExecuteActionL( 

   442                 KFscAtComSendAudio );

   443             break;

   444         case ERclCmdToContact:

   445             iActionServiceWrapper->ExecuteActionL(

   446                 KFscAtComCallPoc );

   447             break;

   448         case ERclCmdHelp:

   449             {

   450             CCoeAppUi* appUi = CCoeEnv::Static()->AppUi();

   451             CArrayFix<TCoeHelpContext>* contexts = appUi->AppHelpContextL();

   452             HlpLauncher::LaunchHelpApplicationL( 

   453                 CCoeEnv::Static()->WsSession(), 

   454                 contexts );

   455             }

   456             break;

   457         default:

   458             handled = EFalse;

   459             break;

   460         }

   461     

   462     if ( !handled )

   463         {

   464         if ( IsStateSet( EResultDlgOnTop ) )

   465             {

   466             switch ( aCommandId )

   467                 {

   468                 case ERclCmdAddAsRecipient:

   469                     // close the dialog, selected contact is stored in iSelectedContact

   470                     AddOperation( ECloseSearchResultDlg );

   471                     SetState( EReturnToCaller );

   472                     SetState( EResultSelected );

   473                     break;

   474                 case ERclCmdViewDetails:

   475                     AddOperation( EOpenResultInfoDlg );

   476                     break;

   477                 case ERclCmdNewSearch:

   478                     // open empty search query

   479                     AddOperation( EOpenSearchQueryEmpty );

   480                     break;

   481                 case ERclCmdSendBusinessCard:

   482                     {

   483                     // first fetch details if they are not already

   484                     // fetched

   485                     HBufC* waitNoteText = StringLoader::LoadLC(

   486                         R_QTN_RCL_RETRIEVAL_WAIT_NOTE );

   487                     if ( RetrieveDetailsL(

   488                              iSearchResultDialog->CurrentItemIndex(),

   489                              *waitNoteText ) != NULL )

   490                         {

   491                         iSearchResultDialog->SendBusinessCardL();

   492                         }

   493                     CleanupStack::PopAndDestroy( waitNoteText );

   494                     }

   495                     break;

   496                 case ERclCmdSaveToContacts:

   497                     {

   498                     // first retrieve all the details

   499                     HBufC* waitNoteText = StringLoader::LoadLC(

   500                         R_QTN_RCL_SAVING_WAIT_NOTE );

   501                     if ( RetrieveDetailsL( 

   502                              iSearchResultDialog->CurrentItemIndex(),

   503                              *waitNoteText ) != NULL )

   504                         {

   505                         

   506                         iActionServiceWrapper->ExecuteActionL( 

   507                             KFscAtManSaveAs );

   508                         

   509                         // in contact selector mode, return to the calling 

   510                         // application

   511                         if ( iMode == EModeContactSelector )

   512                             {

   513                             AddOperation( ECloseSearchResultDlg );

   514                             SetState( EReturnToCaller );

   515                             SetState( EResultSelected );

   516                             }

   517                         }

   518                     CleanupStack::PopAndDestroy( waitNoteText );

   519                     }

   520                     break;

   521                 case EAknCmdExit:

   522                     iResult->iExitReason = TResult::EExitApplication;

   523                     AddOperation( ECloseSearchResultDlg );

   524                     SetState( EReturnToCaller );

   525                     break;

   526                 default:

   527                     break;

   528                 }

   529             }

   530         else if ( IsStateSet( EInfoDlgOnTop ) )

   531             {

   532             switch ( aCommandId )

   533                 {

   534                 case ERclCmdAddAsRecipient:

   535                     // close both dialogs, selected contact is in iSelectedContact

   536                     AddOperation( ECloseResultInfoDlg );

   537                     AddOperation( ECloseSearchResultDlg );

   538                     SetState( EResultSelected );

   539                     SetState( EReturnToCaller );

   540                     break;

   541                 case ERclCmdSendCallbackReq:

   542                     iResultInfoDialog->SendCallbackRequestL();

   543                     break;

   544                 case ERclCmdCreateNew:

   545                     iActionServiceWrapper->ExecuteActionL(

   546                         KFscAtManSaveAs );

   547                     // in contact selector mode, return to the calling

   548                     // application

   549                     if ( iMode == EModeContactSelector )

   550                         {

   551                         AddOperation( ECloseResultInfoDlg );

   552                         AddOperation( ECloseSearchResultDlg );

   553                         SetState( EReturnToCaller );

   554                         SetState( EResultSelected );

   555                         }

   556                     break;

   557                 case ERclCmdUpdateExisting:

   558                     {

   559                     HBufC* resultText = 

   560                         iResultInfoDialog->UpdateExistingContactL();

   561                     if ( resultText != NULL )

   562                         {

   563                         CleanupStack::PushL( resultText );

   564                         DisplayNoteDialogL(

   565                             R_RCL_CONFIRMATION_NOTE,

   566                             *resultText,

   567                             ETrue );

   568                         CleanupStack::PopAndDestroy( resultText );

   569                         }

   570                     }

   571                     break;

   572                 case ERclCmdSendBusinessCard:

   573                     iResultInfoDialog->SendBusinessCardL();

   574                     break;

   575                 case EAknCmdExit:

   576                     // again close both dialogs

   577                     AddOperation( ECloseResultInfoDlg );

   578                     AddOperation( ECloseSearchResultDlg );

   579                     SetState( EReturnToCaller );

   580                     iResult->iExitReason = TResult::EExitApplication;

   581                     break;

   582                 default:

   583                     break;

   584                 }

   585             }

   586         }

   587     }

   588 

   589 // ---------------------------------------------------------------------------

   590 // CPbkxRclServiceUiContextImpl::DialogDismissedL

   591 // ---------------------------------------------------------------------------

   592 //

   593 void CPbkxRclServiceUiContextImpl::DialogDismissedL( TInt aButtonId )

   594     {

   595     FUNC_LOG;

   596 

   597     if ( aButtonId == EAknSoftkeyCancel )

   598         {

   599         

   600         // Action was canceled. Don't need to inform about errors

   601         iExitCode = KErrNone;

   602     	// cancel search or detail retrieval

   603     	if (iSession)

   604     		{

   605     		iSession->Cancel();

   606     		}

   607     	

   608     	// cancel time out timer

   609         if (iTimer)

   610     		{

   611     		iTimer->Cancel();

   612     		}

   613         

   614         // do actions based on state

   615         if ( IsStateSet( EInitial ) )

   616             {

   617             if ( iMode != EModeExistingCriteria )

   618                 {

   619                 // show new search query dialog

   620                 AddOperation( EOpenSearchQueryDefault );

   621                 }

   622             else

   623                 {

   624                 // with existing criteria, exit

   625                 AddOperation( EExit );

   626                 }

   627             }

   628         else if ( IsStateSet( EResultDlgOnTop ) )

   629             {

   630             if ( iWaitObjects.Count() == EContactRetrievalWait + 1 )

   631                 {

   632                 // contact retrieval was in progress

   633                 StopActiveWait( EContactRetrievalWait );

   634                 } // else new search was in progress, no actions needed

   635             }

   636         else if ( IsStateSet( EInfoDlgOnTop ) )

   637             {

   638             // details retrieval was in progress, stop active wait 

   639             StopActiveWait( EContactRetrievalWait );

   640             }

   641         

   642         }

   643     else

   644         {

   645         // wait dialog closed by itself. exit now if exiting

   646         if ( IsStateSet( EReturnToCaller ) &&

   647                 ( IsStateSet( EResultSelected ) || IsStateSet( EInitial ) ) )

   648             {

   649             AddOperation( EExit );

   650             }

   651         

   652         }

   653     }

   654 

   655 // ---------------------------------------------------------------------------

   656 // CPbkxRclServiceUiContextImpl::ExecuteSearchL

   657 // ---------------------------------------------------------------------------

   658 //

   659 void CPbkxRclServiceUiContextImpl::ExecuteSearchL( 

   660     TBool aShowQueryDialog,

   661     const TDesC& aQueryText )

   662     {

   663     FUNC_LOG;

   664 

   665 

   666     iQueryText.Close();

   667     iQueryText.CreateMaxL( KRclQueryTextMaxLength );

   668     iQueryText = aQueryText;

   669 

   670     TBool result = EFalse;

   671     if ( aShowQueryDialog )

   672         {

   673         CPbkxRclQueryEditor* queryEditor = CPbkxRclQueryEditor::NewL( 

   674             iAccount->Name(), 

   675             iQueryText );

   676         result = queryEditor->ExecuteDialogLD();

   677         

   678         // save initial query text given by user

   679         if ( !IsStateSet( EResultDlgOnTop ) )

   680             {

   681             iQueryCriteria = iQueryText;

   682             }

   683         }

   684     else

   685         {

   686         result = ETrue;

   687         }

   688 

   689     if ( result )

   690         {

   691         

   692         // Start time for time out event

   693         iTimer->Start(

   694             KTwoMinutesTimerInterval, KTwoMinutesTimerInterval, 

   695             TCallBack(TimerCallBack, this));

   696         

   697         // execute search based on query text

   698         // use KMaxMatches + 1 to be able to catch "too many results error"

   699         iSession->LooseSearchL( iQueryText, KMaxMatches + 1 );

   700         HBufC* text = StringLoader::LoadLC( R_QTN_RCL_SEARCH_WAIT_NOTE, iQueryText );

   701         DisplayWaitDialogL( R_RCL_SEARCH_WAIT_DIALOG_CANCEL, *text );

   702         CleanupStack::PopAndDestroy( text );

   703         }

   704     else

   705         {

   706         if ( !IsStateSet( EResultDlgOnTop ) )

   707             {

   708             AddOperation( EExit );

   709             } // otherwise just return to search result dlg

   710         }

   711     }

   712 

   713 // ---------------------------------------------------------------------------

   714 // CPbkxRclServiceUiContextImpl::DisplayWaitDialogL

   715 // ---------------------------------------------------------------------------

   716 //

   717 void CPbkxRclServiceUiContextImpl::DisplayWaitDialogL(

   718     TInt aDialogResourceId,

   719     const TDesC& aText )

   720     {

   721     FUNC_LOG;

   722 

   723     iWaitDialog = new ( ELeave ) CAknWaitDialog( NULL, ETrue );

   724     iWaitDialog->SetTextL( aText );

   725     iWaitDialog->SetCallback( this );

   726     iWaitDialog->ExecuteLD( aDialogResourceId );

   727 

   728     }

   729 

   730 // ---------------------------------------------------------------------------

   731 // CPbkxRclServiceUiContextImpl::DisplayNoteDialogL

   732 // ---------------------------------------------------------------------------

   733 //

   734 TBool CPbkxRclServiceUiContextImpl::DisplayNoteDialogL(

   735     TInt aDialogResourceId, 

   736     const TDesC& aText,

   737     TBool aTimeout )

   738     {

   739     FUNC_LOG;

   740     CAknNoteDialog* dialog = NULL;

   741     

   742     if ( aTimeout )

   743         {

   744         dialog = new ( ELeave ) CAknNoteDialog( 

   745             CAknNoteDialog::ENoTone, 

   746             CAknNoteDialog::ELongTimeout );

   747         }

   748     else

   749         {

   750         dialog = new ( ELeave ) CAknNoteDialog();

   751         }

   752 

   753     dialog->PrepareLC( aDialogResourceId );

   754     dialog->SetTextL( aText );

   755         

   756     TBool ret = ( TBool )dialog->RunLD();

   757     

   758 

   759     return ret;

   760     }

   761 

   762 // ---------------------------------------------------------------------------

   763 // CPbkxRclServiceUiContextImpl::DisplayQueryDialogL

   764 // ---------------------------------------------------------------------------

   765 //

   766 //Fix for: EASV-7KFGG3

   767 TBool CPbkxRclServiceUiContextImpl::DisplayQueryDialogL(

   768     TInt aDialogResourceId, 

   769     const TDesC& aText )

   770     {

   771     FUNC_LOG;

   772     CAknQueryDialog* dialog = NULL;

   773     

   774     dialog = new ( ELeave ) CAknQueryDialog();

   775     dialog->PrepareLC( aDialogResourceId );

   776     dialog->SetPromptL( aText );

   777         

   778     TBool ret = ( TBool )dialog->RunLD();

   779     

   780 

   781     return ret;

   782     }

   783 

   784 // ---------------------------------------------------------------------------

   785 // CPbkxRclServiceUiContextImpl::CloseWaitDialogL

   786 // ---------------------------------------------------------------------------

   787 //

   788 void CPbkxRclServiceUiContextImpl::CloseWaitDialogL()

   789     {

   790     FUNC_LOG;

   791     iWaitDialog->ProcessFinishedL();

   792     iWaitDialog = NULL;

   793     }

   794 

   795 // ---------------------------------------------------------------------------

   796 // CPbkxRclServiceUiContextImpl::DisplaySearchResultDialogL

   797 // ---------------------------------------------------------------------------

   798 //

   799 void CPbkxRclServiceUiContextImpl::DisplaySearchResultDialogL()

   800     {

   801     FUNC_LOG;

   802 

   803     if ( iSearchResultDialog == NULL )

   804         {

   805         // no search result dialog on screen, show new one

   806 

   807         // result array holds list box items and it is filled inside search

   808         // result dialog

   809         CDesCArrayFlat* resultArray = 

   810             new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   811         CleanupStack::PushL( resultArray );

   812         

   813         TBool contactSelectorEnabled = iMode == EModeContactSelector;

   814         

   815         iSearchResultDialog = CPbkxRclSearchResultDlg::NewL(

   816             iSelectedIndex,

   817             resultArray,

   818             this,

   819             iContactCards,

   820             *iContactEngine,

   821             *iActionServiceWrapper,

   822             contactSelectorEnabled );

   823         

   824         UnsetState( EInitial );

   825         SetState( EResultDlgOnTop );

   826     

   827         // set action service mode

   828         iActionServiceWrapper->SetActionMenuMode( ETrue );

   829     

   830         iSearchResultDialog->ExecuteLD();

   831         

   832         iActionServiceWrapper->SetActionMenuMode( EFalse );

   833 

   834 

   835         iSearchResultDialog = NULL;

   836         

   837         CleanupStack::PopAndDestroy( resultArray );

   838 

   839         HandleSearchResultDialogExitL();

   840 

   841         UnsetState( EResultDlgOnTop );

   842         SetState( EInitial );

   843         }

   844     else

   845         { // iSearchResultDialog != NULL

   846         

   847         

   848         iSearchResultDialog->UpdateDialogL();

   849         }

   850     }

   851 // ---------------------------------------------------------------------------

   852 // CPbkxRclServiceUiContextImpl::DisplayResultInfoDialogL

   853 // ---------------------------------------------------------------------------

   854 //

   855 void CPbkxRclServiceUiContextImpl::DisplayResultInfoDialogL()

   856     {

   857     FUNC_LOG;

   858     

   859     // items array holds the list box items in result info dialog and it is filled

   860     // result info dialog

   861     CDesCArrayFlat* items = new ( ELeave ) CDesCArrayFlat( KArrayGranularity );

   862     CleanupStack::PushL( items );

   863     

   864     TInt index = 0;

   865     

   866     TBool contactSelectorEnabled = iMode == EModeContactSelector;

   867 

   868     TInt itemIndex = iSearchResultDialog->CurrentItemIndex();

   869 

   870     // creation fails if item details cannot be retrieved or user cancels

   871     // retrieval

   872     iResultInfoDialog = CPbkxRclResultInfoDlg::NewL(

   873         index,

   874         items,

   875         this,

   876         this,

   877         *iContactEngine,

   878         *iActionServiceWrapper,

   879         contactSelectorEnabled,

   880         itemIndex );

   881     

   882     UnsetState( EResultDlgOnTop );

   883     SetState( EInfoDlgOnTop );

   884     

   885      // set action service mode

   886     iActionServiceWrapper->SetActionMenuMode( EFalse );

   887     

   888     //Fix for: PKAO-7NNCJ2

   889     if ( iSearchResultDialog )

   890         {

   891         iSearchResultDialog->InfoDlgVisible( ETrue );

   892         }

   893     

   894     iResultInfoDialog->ExecuteLD();

   895     

   896     // update action service since now search result dialog is on top

   897     iActionServiceWrapper->SetActionMenuMode( ETrue );

   898 

   899     if ( !IsStateSet( EReturnToCaller ) && iResult->iExitReason != TResult::EExitApplication )

   900     	{

   901     	iSearchResultDialog->SetCurrentContactToActionServiceL();

   902     	}

   903     

   904     //Fix for: PKAO-7NNCJ2

   905     if ( iSearchResultDialog )

   906         {

   907         iSearchResultDialog->InfoDlgVisible( EFalse );

   908         }

   909     

   910     iResultInfoDialog = NULL;

   911     

   912     UnsetState( EInfoDlgOnTop );

   913     SetState( EResultDlgOnTop );

   914         

   915     CleanupStack::PopAndDestroy( items );

   916     

   917     }

   918 

   919 // ---------------------------------------------------------------------------

   920 // CPbkxRclServiceUiContextImpl::CreateContactCardArray

   921 // ---------------------------------------------------------------------------

   922 //

   923 void CPbkxRclServiceUiContextImpl::CreateContactCardArray()

   924     {

   925     FUNC_LOG;

   926 

   927     // remove possible old contact cards

   928     iContactCards.Reset();

   929     

   930 

   931     for ( TInt i = 0; i < iSearchResults.Count(); i++ )

   932         {

   933         CContactItem& item = iSearchResults[i]->ContactItem();

   934         CContactCard* card = dynamic_cast<CContactCard*>( &item );

   935         if ( card != NULL )

   936             {

   937             iContactCards.Append( card );

   938             }

   939         }

   940 

   941 

   942     }

   943 

   944 // ---------------------------------------------------------------------------

   945 // CPbkxRclServiceUiContextImpl::DoLooseSearchCompletedL

   946 // ---------------------------------------------------------------------------

   947 //

   948 void CPbkxRclServiceUiContextImpl::DoLooseSearchCompletedL( 

   949     TInt aStatus,

   950     RPointerArray<CPbkxRemoteContactLookupProtocolResult>& aResults )

   951     {

   952     FUNC_LOG;

   953 	

   954     // cancel time out timer

   955     if (iTimer)

   956 		{

   957 		iTimer->Cancel();

   958 		}

   959     

   960     CloseWaitDialogL();

   961 

   962     if ( aStatus == KErrNone )

   963         {

   964         if ( aResults.Count() > KMaxMatches )

   965             {

   966             

   967             HBufC* text = StringLoader::LoadLC( 

   968                 R_QTN_RCL_TOO_MANY_RESULTS_NOTE, 

   969                 KMaxMatches );

   970 

   971             TBool ret = DisplayQueryDialogL(

   972                 R_RCL_CONFIRMATION_NOTE_OK_REFINE,

   973                 *text );

   974             

   975             CleanupStack::PopAndDestroy( text );

   976             

   977             if ( !ret )

   978                 {

   979                 // user wants new search

   980                 AddOperation( EOpenSearchQueryDefault );

   981 

   982                 // reset the old results

   983                 aResults.ResetAndDestroy();

   984                 return;

   985                 }

   986             }

   987         

   988         // delete old results

   989         iSearchResults.ResetAndDestroy();

   990         TInt count = aResults.Count() <= KMaxMatches ? aResults.Count() : KMaxMatches;

   991         for ( TInt i = 0; i < count; i++ )

   992             {

   993             iSearchResults.AppendL( aResults[i] );

   994             }

   995 

   996         // delete the extra results

   997         for ( TInt j = aResults.Count() - 1; j >= KMaxMatches; j-- )

   998             {

   999             delete aResults[j];

  1000             aResults.Remove( j );

  1001             }

  1002         

  1003         CreateContactCardArray();

  1004         TLinearOrder<CContactCard> sort( CPbkxRclServiceUiContextImpl::Sort );

  1005         iContactCards.Sort( sort );

  1006         

  1007         AddOperation( EOpenSearchResultDlg );

  1008         }

  1009     else

  1010         {

  1011 

  1012         // reset the array just in case

  1013         aResults.ResetAndDestroy();

  1014 

  1015         // remote contact lookup failed, exit

  1016         HandleError( aStatus );

  1017         

  1018         }

  1019     }

  1020 

  1021 // ---------------------------------------------------------------------------

  1022 // CPbkxRclServiceUiContextImpl::DoContactFieldsRetrievalCompletedL

  1023 // ---------------------------------------------------------------------------

  1024 //

  1025 void CPbkxRclServiceUiContextImpl::DoContactFieldsRetrievalCompletedL( TInt aStatus )

  1026     {

  1027     FUNC_LOG;

  1028 

  1029 	// cancel time out timer

  1030     if (iTimer)

  1031 		{

  1032 		iTimer->Cancel();

  1033 		}

  1034     

  1035     StopActiveWait( EContactRetrievalWait );

  1036 

  1037     CloseWaitDialogL();

  1038 

  1039     if ( aStatus != KErrNone )

  1040         {

  1041         // error occurred, so contact is not complete. this is checked

  1042         // in RetrieveContactDetailsL method and it returns NULL

  1043         // to the caller

  1044 

  1045         // exit application

  1046         HandleError( aStatus );

  1047         }

  1048     

  1049     }

  1050 

  1051 // ---------------------------------------------------------------------------

  1052 // CPbkxRclServiceUiContextImpl::DoHandleOperationL

  1053 // ---------------------------------------------------------------------------

  1054 //

  1055 void CPbkxRclServiceUiContextImpl::DoHandleOperationL()

  1056     {

  1057     FUNC_LOG;

  1058 

  1059     if ( iOperations.Count() > 0 )

  1060         {

  1061         TOperation operation = iOperations.Pop();

  1062         

  1063         

  1064         switch ( operation )

  1065             {

  1066             case EOpenSearchResultDlg:

  1067                 DisplaySearchResultDialogL();

  1068                 break;

  1069             case EOpenResultInfoDlg:

  1070                 DisplayResultInfoDialogL();

  1071                 break;

  1072             case ECloseSearchResultDlg:

  1073                 if ( iSearchResultDialog != NULL )

  1074                     {

  1075                     iSearchResultDialog->Close();

  1076                     }

  1077                 break;

  1078             case ECloseResultInfoDlg:

  1079                 if ( iResultInfoDialog != NULL )

  1080                     {

  1081                     iResultInfoDialog->Close();

  1082                     }

  1083                 break;

  1084             case EOpenSearchQueryDefault:

  1085                 ExecuteSearchL( ETrue, iQueryCriteria );

  1086                 break;

  1087             case EOpenSearchQueryEmpty:

  1088                 ExecuteSearchL( ETrue, KNullDesC );

  1089                 break;

  1090             case EExecuteSearchWithNoQuery:

  1091                 ExecuteSearchL( EFalse, iQueryCriteria );

  1092                 break;

  1093             case EExit:

  1094                 StopActiveWait( EMainWait );

  1095                 break;

  1096             default:

  1097                 PbkxRclPanic( EPbkxRclPanicGeneral );

  1098                 break;

  1099             }

  1100         

  1101         if ( iOperations.Count() > 0 )

  1102             {

  1103             iEventScheduler->TriggerEvent();

  1104             }

  1105         }

  1106     }

  1107 

  1108 // ---------------------------------------------------------------------------

  1109 // CPbkxRclServiceUiContextImpl::HandleSearchResultDialogExitL

  1110 // ---------------------------------------------------------------------------

  1111 //

  1112 void CPbkxRclServiceUiContextImpl::HandleSearchResultDialogExitL()

  1113     {

  1114     FUNC_LOG;

  1115 

  1116     // this flag is set if wait dialog on the screen and we cannot exit before

  1117     // wait dialog is closed itself

  1118     TBool waitDlgOnScreen = EFalse;

  1119     

  1120     if ( IsStateSet( EResultSelected ) )

  1121         {

  1122         // if contact details are not retrieved, we must do that before exiting

  1123         CPbkxRemoteContactLookupProtocolResult* result = GetResultByIndex( iSelectedIndex );

  1124         if ( !result->IsComplete() )

  1125             {

  1126             HBufC* text = StringLoader::LoadLC( R_QTN_RCL_RETRIEVAL_WAIT_NOTE );

  1127             RetrieveDetailsL( iSelectedIndex, *text );

  1128             CleanupStack::PopAndDestroy( text );

  1129             

  1130             // if wait dialog is NULL, it is closed by CloseWaitDialogL method

  1131             // and not by user. so it is still on the screen

  1132             waitDlgOnScreen = iWaitDialog == NULL;

  1133             

  1134             // make sure we succeeded in detail retrieving. if not, return nothing.