/*

* Copyright (c) 2004-2005 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 CallUIEngine.

*

*/

// INCLUDE FILES

#include    "CaUiEngine.h"

#include    "CaUiQuery.h"               // CCaUiQuery.

#include    <mcauireconnectqueryobserver.h>  // MCaUiReconnectQueryObserver.

#include    <CallUI.rsg>                // Resources.

#include    <cphcltdialer.h>            // CPhCltDialer.

#include    <cphonecntfactory.h>

#include    <cphcntsingleitemfetch.h>

#include    <aiwinternaldialdata.h>

#include    <AiwServiceHandler.h>

#include    <cphcltextphonedialdata.h>  // CPhCltExtPhoneDialData

#include    "callui.loc"                // Localized strings.

#include    <StringLoader.h>            // String Loader.

#include    <aknnotewrappers.h>         // CAknInformationNote.

#include    <AknGlobalListQuery.h>      // CAknGlobalListQuery.

#include    <featmgr.h>                 // FeatureManager.

#include    <AknGlobalConfirmationQuery.h> // Confirmation query.

#include    <PhCltUtils.h>              // Character removal.

#include    <AiwCommon.h>               // AIW dialdata.

#include    <NetworkHandlingDomainPSKeys.h>

#include    <e32property.h>             // Pub&Sub functionality.

#include    "CaUiVoIPExtension.h"        // VoIP/SCCP profile store

#include    <centralrepository.h>

#include    <settingsinternalcrkeys.h>

#include     "cauilogger.h"        // Call Ui Logger

#include    <aknmessagequerydialog.h> 

#include    <AknGlobalNote.h>

#include    <mphcntstoreloader.h>

#include    <MVPbkContactStore.h>

#include "CaUiDialogs.h"

// CONSTANTS

// GSM Network.

const TInt KCaUiEngGsmNetwork = ENWNetworkModeGsm;

// WCDMA Network.

const TInt KCaUiEngWcdmaNetwork = ENWNetworkModeWcdma;

_LIT( KCallTypeUriParam, "call-type" );

_LIT( KCallTypeVideo, "video" );

_LIT( KSemiColon, ";" );

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

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

// CCaUiEngine::CCaUiEngine

// 

// C++ default constructor can NOT contain any code, that might leave.

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

//

CCaUiEngine::CCaUiEngine()

:   iResourceLoader( *CCoeEnv::Static() )

    {

    }

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

// CCaUiEngine::ConstructL

// 

// Symbian 2nd phase constructor can leave.

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

//

void CCaUiEngine::ConstructL()

    {

    CAUILOGSTRING("CALLUI: >>>CCaUiEngine::ConstructL() Begin");

    // Sets up TLS, must be done before FeatureManager is used.

    FeatureManager::InitializeLibL();

    if ( CCoeEnv::Static() )

        {

        // Open CallUI resource file.

        TFileName* name = new ( ELeave ) TFileName( KCallUIResFile );

        CleanupStack::PushL( name );

        User::LeaveIfError( iResourceLoader.Open( *name ) );

        CleanupStack::PopAndDestroy( name );

        }

    // Get info is VoIP supported

    iVoIPProfileHandler = CCaUiVoIPExtension::NewL();

    iLongPressSet = ECaUiLongPressKeyNotSet;

    iServiceSelector = CConvergedServiceSelector::NewL();

    iDialogs = CCaUiDialogs::NewL( *this );

    CAUILOGSTRING("CALLUI: >>>CCaUiEngine::ConstructL() Complete");

    }

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

// CCaUiEngine::NewL

// 

// Two-phased constructor.

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

//

CCaUiEngine* CCaUiEngine::NewL()

    {

    CCaUiEngine* self = new( ELeave ) CCaUiEngine;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCaUiEngine::~CCaUEngine

// 

// Destructor.

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

//

CCaUiEngine::~CCaUiEngine()

    {

    delete iServiceSelector;

    // Delete VoIP extension if VoIP is supported

    if ( iVoIPProfileHandler )

        {

        delete iVoIPProfileHandler;

        }

    delete iEmergencyCall;      

    delete iContactSelector;

    delete iFactory;

    delete iVTSettingQuery;

    // Clear dial components.

    ClearDialContents();

    if ( CCoeEnv::Static() )

        {

        // Close resource loader.

        iResourceLoader.Close();

        }

    // Delete the menubuffer.

    delete iBuf;

    iBuf = NULL;

    delete iVTString;

    iVTString = NULL;

    delete iContactStoreLoader;

    delete iDialogs;

    // Frees the TLS! Must be done after FeatureManager is used.

    FeatureManager::UnInitializeLib();

    }

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

// CCaUiEngine::DialL

// 

// 

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

//

void CCaUiEngine::DialL(

    MCaUiDialResultObserver& aObserver,

    const TDesC8& aDialData,

    const TCaUiCallType aCallType )

    {

    CAUILOGSTRING("CALLUI: >>>CCaUiEngine::DialL() Begin");

    iDialogs->SetReconfQueryOngoing( EFalse );

    // If iPhCltDialer and iDialData exist, 

    // destroy them and create new ones. This clears the dial data.

    ClearDialContents();

    iPhCltDialer = CPhCltExtPhoneBase::NewL( this );

    iObserver = &aObserver;

    iDialData = CPhCltExtPhoneDialData::NewL();

    CAiwInternalDialData* aiwDialData = CAiwInternalDialData::NewLC( aDialData );

    TPhCltTelephoneNumber  aiwTelNumber( aiwDialData->PhoneNumber() );

    HBufC* uriParams = FindAndRipURIParametersL( aiwTelNumber );

    CleanupStack::PushL( uriParams );

    aiwDialData->SetPhoneNumberL( aiwTelNumber );

    // ConvertDialDataL overwrites, if given in aDialData

    SetDialDataCallType( aCallType );

    // Convert AIW dial data to PhoneClient format.

    ConvertDialDataL( *aiwDialData  );

    // Check if there has been a long press of Send key

    if ( iDialData->InitiateCall() )

        {

        HandleLongPressOfSendKeyL();

        }

    iDialData->SetSendKeyPressed( 

        IsSendKeyPressed( aCallType, aiwDialData->CallType() ) );

    // By default call is made, unless user cancels the procedure.

    TBool createCall = ETrue;

    TPhCltCallType callType = iDialData->CallType();

    if ( aCallType == ECaUiCallTypeVoice )

        {

        iDialData->SetCallType( EPhCltVoice );

        }

    // If not forced video call is wanted, ask user to confirm it.

    // ECaUiCallTypeUnknown indicates that the call is not made from options menu.

    else if ( iDialData->CallType() == EPhCltVideo 

                            && aCallType == ECaUiCallTypeUnknown )

        {

        // Get preferred call-type from URI params, it will be passed to

        // list query and selected by default

        callType = CallTypeFromUriParams( *uriParams );

        // If query is canceled, then call is not made.

        createCall = iDialogs->LaunchCreateListQueryL( callType );

        // Set the call type, video must be forced

        if ( EPhCltVideo == callType )

            {

            iDialData->SetCallType( EPhCltForcedVideo );

            }

        else

            {

            iDialData->SetCallType( callType );

            }

        }

    else if ( aCallType == ECaUiCallTypeInternet )

        {

        iDialData->SetCallType( EPhCltCallVoIP );

        }

    else if ( aCallType == ECaUiCallTypeVideo )

        {

        // (Forced) video call must be created.

        iDialData->SetCallType( EPhCltForcedVideo );

        }

    CleanupStack::PopAndDestroy( uriParams );

    // If user did not Cancel query or query was not shown, 

    // perform the dial operation.

    if ( createCall )

        {

        if ( iDialData->ContactLink() != KNullDesC8() 

            && !aiwDialData->PhoneNumber().Length() )

            {

            TBool storeLoaded 

                = LaunchContactStoreLoadingL( iDialData->ContactLink() );

            if ( storeLoaded )

                {

                // Launch address select.

                // aCallType describes which selector is used. ( VoIP/PhoneNumber )

                LaunchAddressSelectL( iDialData->ContactLink(), aCallType );

                }

            }

        else 

            {

            PhoneClientDialL( NULL );

            }

        }

    else

        {

        HandleDialL( KErrCancel );

        }

    CleanupStack::PopAndDestroy( aiwDialData );

    CAUILOGSTRING("CALLUI: >>>CCaUiEngine::DialL() End");

    }

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

// CCaUiEngine::LaunchNoNetSupNoteL

// 

// 

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

//

void CCaUiEngine::LaunchNoNetSupNoteL()

    {

    iDialogs->LaunchNoNetSupNoteL();

    }

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

// CCaUiEngine::LaunchReconConfQueryL

// 

// 

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

//

void CCaUiEngine::LaunchReconConfQueryL( 

    MCaUiReconnectQueryObserver& aObserver,

    CPhCntMatcher* aPhCntMatcher,

    const TPtrC aPhoneNumber,

    const TBool aIncludeVideoCallOption )

    {

    // Empty pointer.

    TPtrC ptrc;

    iDialogs->LaunchReconConfQueryL(

        aObserver,

        aPhCntMatcher,

        aPhoneNumber,

        aIncludeVideoCallOption,

        ptrc );

    }

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

// CCaUiEngine::CancelReconConfQuery

// 

// 

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

//

void CCaUiEngine::CancelReconConfQuery()

    {

    iDialogs->CancelReconConfQuery();

    }

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

// CCaUiEngine::LaunchNoteAndReconConfQueryL

// 

// 

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

//

void CCaUiEngine::LaunchNoteAndReconConfQueryL( 

    MCaUiReconnectQueryObserver& aObserver,

    CPhCntMatcher* aPhCntMatcher,

    const TPtrC aPhoneNumber,

    const TBool aIncludeVideoCallOption,

    const TPtrC aNoteText )

    {

    // Empty pointer.

    const TPtrC ptrc;

    iDialogs->LaunchNoteAndReconConfQueryL( 

        aObserver,

        aPhCntMatcher,

        aPhoneNumber,

        aIncludeVideoCallOption,

        aNoteText,

        ptrc );

    }

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

// CCaUiEngine::CancelNoteAndReconConfQuery

// 

// 

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

//

void CCaUiEngine::CancelNoteAndReconConfQuery()

    {

    iDialogs->CancelNoteAndReconConfQuery();

    }

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

// CCaUiEngine::LaunchAddressSelectL

// 

// 

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

//

TBool CCaUiEngine::LaunchAddressSelectL(

    TDes& aTelNum, 

    const TInt aContactId,

    const TBool aVoIPAddressSelect )

    {

    TBool addressSelected( EFalse );

    TCaUiCallType callType( ECaUiCallTypeVoice );

    if ( aVoIPAddressSelect )

        {

        callType = ECaUiCallTypeInternet;

        }

    addressSelected = LaunchAddressSelectL( aTelNum, aContactId, callType );

    return addressSelected;

    }

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

// CCaUiEngine::CancelAddressSelect

// 

// 

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

//

void CCaUiEngine::CancelAddressSelect()

    {

    }

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

// From MPhCntStoreLoaderObserver.

// CCaUiEngine::ContactStoreLoadingCompleted

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

//

void CCaUiEngine::ContactStoreLoadingCompleted( 

        MVPbkContactStore* /*aStore*/, TInt aErrorCode )

    {

    TInt result( aErrorCode );

    if ( KErrNone == result )

        {

        TCaUiCallType caUiCallType( ECaUiCallTypeUnknown );

        ConvertPhCltCallType( iDialData->CallType(), caUiCallType );

        TRAP( result, 

            LaunchAddressSelectL( iDialData->ContactLink(), caUiCallType ) );

        }

    if ( KErrNone != result )

        {

        TRAP_IGNORE( HandleDialL( aErrorCode ) );

        }

    }

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

// CCaUiEngine::HandleDialL

// 

// 

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

//

void CCaUiEngine::HandleDialL( const TInt aStatus )

    {

    if ( iObserver )

        {

        iObserver->HandleDialResultL( aStatus );

        }

    if ( !iDialogs->IsReconfQueryOngoing() )

        {

        ClearDialContents();

        }

    }

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

// CCaUiEngine::OptionSelected

// 

// 

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

//

void CCaUiEngine::OptionSelected( TCaUiReconType aReconType )

    {

    CAUILOGSTRING("CALLUI: >>>CCaUiEngine::OptionSelected() Begin");

    if ( aReconType == ECallUiReconTypeVoice ||

         aReconType == ECallUiReconTypeVideo )

        {

        // Call is wanted to be made. Do it only if Dial data exists.

        if ( iDialData )

            {

            iDialogs->SetReconfQueryOngoing( EFalse );

            if( aReconType == ECallUiReconTypeVoice )

                {

                // Make sure that call type is correct, i.e. voice call.

                iDialData->SetCallType( EPhCltVoice );

                }

            else

                {

                // Make sure that call type is correct, i.e. video call.

                iDialData->SetCallType( EPhCltVideo );

                }

            TRAPD( err, iPhCltDialer->DialL( *iDialData ) );

            if( err )

                {

                CAUILOGSTRING2("CALLUI: >>>CCaUiEngine DialL error = %d", err );

                }

            }

        }

    CAUILOGSTRING("CALLUI: >>>CCaUiEngine::OptionSelected() End");

    }

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

// CCaUiEngine::ConvertDialDataL

// 

// 

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

//

void CCaUiEngine::ConvertDialDataL(

    const CAiwInternalDialData& aAiwDialData )

    {

    // Telephony number.

    iDialData->SetTelephoneNumber( aAiwDialData.PhoneNumber().Left( 

        iDialData->TelephoneNumber().MaxLength() ) );

    // Call type.

    CAiwDialData::TCallType aiwCallType = aAiwDialData.CallType();

    TPhCltCallType phCltCallType = EPhCltVoice;