/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of the class CPbkxRclServiceUiContextImpl.

*

*/

#include "emailtrace.h"

#include <pbk2rclengine.rsg>

#include <cntfldst.h>

#include <StringLoader.h>

#include <CPbkContactEngine.h>

#include <bautils.h>

#include <textresolver.h>

#include "fsccontactactionservicedefines.h"

#include <data_caging_path_literals.hrh>

#include <AknsUtils.h>

#include <hlplch.h>

#include "cpbkxrclserviceuicontextimpl.h"

#include "pbkxremotecontactlookuppanic.h"

#include <cpbkxremotecontactlookupprotocolsession.h>

#include <cpbkxremotecontactlookupprotocoladapter.h>

#include <cpbkxremotecontactlookupprotocolaccount.h>

#include "cpbkxrclprotocolenvimpl.h"

#include "cpbkxrclsearchresultdlg.h"

#include "cpbkxrclresultinfodlg.h"

#include "cpbkxrclqueryeditor.h"

#include "cpbkxrclactionservicewrapper.h"

#include "pbkxrclutils.h"

#include "pbkxrclengineconstants.h"

#include "engine.hrh"

#include <aknnotewrappers.h>

/// Unnamed namespace for local definitions

namespace {

const TInt KTwoMinutesTimerInterval(120000000);

} /// namespace

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

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::NewL

// ---------------------------------------------------------------------------

//

CPbkxRclServiceUiContextImpl* CPbkxRclServiceUiContextImpl::NewL(

    TPbkxRemoteContactLookupProtocolAccountId aId,

    TMode aMode )

    {

    FUNC_LOG;

    CPbkxRclServiceUiContextImpl* context = 

        CPbkxRclServiceUiContextImpl::NewLC( aId, aMode );

    CleanupStack::Pop( context );

    return context;

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::NewLC

// ---------------------------------------------------------------------------

//

CPbkxRclServiceUiContextImpl* CPbkxRclServiceUiContextImpl::NewLC(

    TPbkxRemoteContactLookupProtocolAccountId aId,

    TMode aMode )

    {

    FUNC_LOG;

    CPbkxRclServiceUiContextImpl* context = 

        new ( ELeave ) CPbkxRclServiceUiContextImpl( aId, aMode );

    CleanupStack::PushL( context );

    context->ConstructL();

    return context;

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::CPbkxRclServiceUiContextImpl

// ---------------------------------------------------------------------------

//

CPbkxRclServiceUiContextImpl::CPbkxRclServiceUiContextImpl(

    TPbkxRemoteContactLookupProtocolAccountId aId,

    TMode aMode ) : 

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

    {

    FUNC_LOG;

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::~CPbkxRclServiceUiContextImpl

// ---------------------------------------------------------------------------

//

CPbkxRclServiceUiContextImpl::~CPbkxRclServiceUiContextImpl()

    {

    FUNC_LOG;

    if( iTimer )

        {

        iTimer->Cancel();

        }

    delete iTimer;

    iQueryText.Close();

    iQueryCriteria.Close();

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

    iContactCards.Reset();

    iSearchResults.ResetAndDestroy();

    iWaitObjects.ResetAndDestroy();

    delete iContactEngine;

    delete iActionServiceWrapper;

    delete iAccount;

    delete iSession;

    delete iAdapter;

    delete iEnvImpl;

    delete iEventScheduler;

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::ConstructL

// ---------------------------------------------------------------------------

//

void CPbkxRclServiceUiContextImpl::ConstructL()

    {

    FUNC_LOG;

    CCoeEnv* coeEnv = CCoeEnv::Static();

    TFileName dllFileName;

    Dll::FileName( dllFileName );

    TParse parse;

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

    TFileName resourceFile = parse.FullName();

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

    TRAPD( status,

           iResourceFileOffset = coeEnv->AddResourceFileL( resourceFile ) );

    if( status != KErrNone )

        {

    	PbkxRclPanic( EPbkxRclPanicGeneral );		

        }

	else 

        {

        }

    // create default contact engine to use to create CPbkContactItems

    iContactEngine = CPbkContactEngine::NewL();

    // create actions service wrapper used by UI views

    iActionServiceWrapper = CPbkxRclActionServiceWrapper::NewL( *iContactEngine );

    iActionServiceWrapper->SetContactSelectorMode( 

        iMode == EModeContactSelector );

    // Create objects needed for executing the search

    iEnvImpl = CPbkxRclProtocolEnvImpl::NewL();

    iAdapter = CPbkxRemoteContactLookupProtocolAdapter::NewL( 

        iAccountId.iProtocolUid, 

        *iEnvImpl );

    iAccount = iAdapter->NewProtocolAccountL( iAccountId );

    if ( iAccount == NULL )

        {

        User::Leave( KErrNotFound );

        }

    iSession = iAdapter->NewSessionL();

    iSession->InitializeL( *this, iAccountId );

    iEventScheduler = CPbkxRclEventScheduler::NewL( *this );

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

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::GetSelectedContactL

// ---------------------------------------------------------------------------

//

CContactItem* CPbkxRclServiceUiContextImpl::GetSelectedContactL()

    {

    FUNC_LOG;

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

                     PbkxRclPanic( EPbkxRclPanicGeneral ) );

    CContactCard* selected = iContactCards[iSelectedIndex];

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

    return copy;

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::GetResultByIndex

// ---------------------------------------------------------------------------

//

CPbkxRemoteContactLookupProtocolResult* 

CPbkxRclServiceUiContextImpl::GetResultByIndex( TInt aIndex )

    {

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

                     PbkxRclPanic( EPbkxRclPanicGeneral ) );

    CContactCard* card = iContactCards[aIndex];

    CPbkxRemoteContactLookupProtocolResult* result = NULL;

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

        {

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

            {

            result = iSearchResults[i];

            break;

            }

        }

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

    return result;

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::ExecuteL

// ---------------------------------------------------------------------------

//

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

    {

    FUNC_LOG;

    // set state as initial

    ResetState();

    SetState( EInitial );

    iExitCode = KErrNone;

    iSearchResults.ResetAndDestroy();

    iQueryCriteria.Close();

    iQueryCriteria.CreateL( KRclQueryTextMaxLength );

    iQueryCriteria = aQueryText.Left( KRclQueryTextMaxLength );

    iResult = &aResult;

    TOperation op = ( iMode != EModeExistingCriteria ) ? 

        EOpenSearchQueryDefault : EExecuteSearchWithNoQuery;

    AddOperation( op );

    StartActiveWaitL( EMainWait );

    HandleContextExitL();

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::LooseSearchCompleted

// ---------------------------------------------------------------------------

//

void CPbkxRclServiceUiContextImpl::LooseSearchCompleted(

    TInt aStatus,

    RPointerArray<CPbkxRemoteContactLookupProtocolResult>& aResults )

    {

    FUNC_LOG;

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

    if ( err != KErrNone )

        {

        HandleError( err );

        }

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::ContactFieldsRetrievalCompleted

// ---------------------------------------------------------------------------

//

void CPbkxRclServiceUiContextImpl::ContactFieldsRetrievalCompleted( TInt aStatus )

    {

    FUNC_LOG;

    TRAPD( err, DoContactFieldsRetrievalCompletedL( aStatus ) );

    if ( err != KErrNone )

        {

        HandleError( err );

        }

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::RetrieveDetailsL

// ---------------------------------------------------------------------------

//

CContactCard* CPbkxRclServiceUiContextImpl::RetrieveDetailsL( 

    TInt aContactIndex,

    const TDesC& aWaitNoteText )

    {

    FUNC_LOG;

    CPbkxRemoteContactLookupProtocolResult* result = GetResultByIndex( aContactIndex );

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

    if ( !result->IsComplete() )

        {

        RPointerArray<CPbkxRemoteContactLookupProtocolResult> array;

        CleanupClosePushL( array );

        array.AppendL( result );

        iSession->RetrieveContactFieldsL( array );

        // Start time for time out event

        iTimer->Start(

        		KTwoMinutesTimerInterval, KTwoMinutesTimerInterval, 

            TCallBack(TimerCallBack, this));

        DisplayWaitDialogL( R_RCL_SEARCH_WAIT_DIALOG_CANCEL, aWaitNoteText );

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

        // ContactFieldsRetrievalCompleted is called. If user cancels

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

        StartActiveWaitL( EContactRetrievalWait );

        CleanupStack::PopAndDestroy( &array );

        // if contact retrieval was canceledor retrieval failed, 

        // result is not yet complete

        if ( !result->IsComplete() )

            {

            card = NULL;

            }

        }

    return card;

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::ContactCount

// ---------------------------------------------------------------------------

//

TInt CPbkxRclServiceUiContextImpl::ContactCount() const

    {

    FUNC_LOG;

    return iContactCards.Count();

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::SetSelectedContact

// ---------------------------------------------------------------------------

//

void CPbkxRclServiceUiContextImpl::SetSelectedContactL( TInt aIndex )

    {

    FUNC_LOG;

    iSearchResultDialog->SetCurrentItemIndexL( aIndex );

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::EventTriggered

// ---------------------------------------------------------------------------

//

void CPbkxRclServiceUiContextImpl::EventTriggered()

    {

    FUNC_LOG;

    TRAPD( err, DoHandleOperationL() );

    if ( err != KErrNone )

        {

        HandleError( err );

        }

    }

// ---------------------------------------------------------------------------

// CPbkxRclServiceUiContextImpl::ProcessCommandL

// ---------------------------------------------------------------------------

//

void CPbkxRclServiceUiContextImpl::ProcessCommandL( TInt aCommandId )

    {

    FUNC_LOG;

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

    TBool handled = ETrue;

    switch ( aCommandId )

        {

        case ERclCmdVoiceCall:

            iActionServiceWrapper->ExecuteActionL( 

                KFscAtComCallGSM );

            break;

        case ERclCmdVideoCall:

            iActionServiceWrapper->ExecuteActionL( 

                KFscAtComCallVideo );

            break;

        case ERclCmdVoip:

            iActionServiceWrapper->ExecuteActionL(

                KFscAtComCallVoip );

            break;

        case ERclCmdSendMsg:

            iActionServiceWrapper->ExecuteActionL( 

                KFscAtComSendMsg );

            break;

        case ERclCmdSendEmail:

            iActionServiceWrapper->ExecuteActionL( 

                KFscAtComSendEmail );

            break;

        case ERclCmdSendMeetingReq:

            iActionServiceWrapper->ExecuteActionL( 

                KFscAtComSendCalReq );

            break;

        case ERclCmdSendAudioMsg:

            iActionServiceWrapper->ExecuteActionL( 

                KFscAtComSendAudio );

            break;

        case ERclCmdToContact:

            iActionServiceWrapper->ExecuteActionL(

                KFscAtComCallPoc );

            break;

        case ERclCmdSendBusinessCard:

            iActionServiceWrapper->ExecuteActionL( 

                        KFscAtSendBusinessCard );

            break;

        case ERclCmdHelp:

            {

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

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

            HlpLauncher::LaunchHelpApplicationL( 

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

                contexts );

            }

            break;

        default:

            handled = EFalse;

            break;

        }

    if ( !handled )

        {

        if ( IsStateSet( EResultDlgOnTop ) )

            {

            switch ( aCommandId )

                {

                case ERclCmdAddAsRecipient:

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

                    AddOperation( ECloseSearchResultDlg );

                    SetState( EReturnToCaller );

                    SetState( EResultSelected );

                    break;

                case ERclCmdViewDetails:

                    AddOperation( EOpenResultInfoDlg );

                    break;

                case ERclCmdNewSearch:

                    // open empty search query

                    AddOperation( EOpenSearchQueryEmpty );

                    break;

                case ERclCmdNewSearchPrefilled:

                    // open empty search query

                    AddOperation( EOpenSearchQueryDefault );

                    break;

                case ERclCmdSaveToContacts:

                    {

                    // first retrieve all the details

                    HBufC* waitNoteText = StringLoader::LoadLC(

                        R_QTN_RCL_SAVING_WAIT_NOTE );

                    if ( RetrieveDetailsL( 

                             iSearchResultDialog->CurrentItemIndex(),

                             *waitNoteText ) != NULL )

                        {

                        iActionServiceWrapper->ExecuteActionL( 

                            KFscAtManSaveAs );

                        // in contact selector mode, return to the calling 

                        // application

                        if ( iMode == EModeContactSelector )

                            {

                            AddOperation( ECloseSearchResultDlg );

                            SetState( EReturnToCaller );

                            SetState( EResultSelected );

                            }

                        }

                    CleanupStack::PopAndDestroy( waitNoteText );

                    }

                    break;

                case EAknCmdExit:

                    iResult->iExitReason = TResult::EExitApplication;

                    AddOperation( ECloseSearchResultDlg );

                    SetState( EReturnToCaller );

                    break;

                default:

                    break;

                }

            }

        else if ( IsStateSet( EInfoDlgOnTop ) )

            {

            switch ( aCommandId )

                {

                case ERclCmdAddAsRecipient:

                    // close both dialogs, selected contact is in iSelectedContact

                    AddOperation( ECloseResultInfoDlg );

                    AddOperation( ECloseSearchResultDlg );

                    SetState( EResultSelected );

                    SetState( EReturnToCaller );

                    break;

                case ERclCmdSendCallbackReq:

                    iResultInfoDialog->SendCallbackRequestL();

                    break;

                case ERclCmdAddToContacts:     

                    iActionServiceWrapper->ExecuteActionL(

                        KFscAtManSaveAs );

                    // in contact selector mode, return to the calling

                    // application

                    if ( iMode == EModeContactSelector )