/*

* 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, stub version.

*

*/

// INCLUDE FILES

#include    "cauiengine.h" 

#include    "cauidialogs.h" 

#include    <callui.rsg> // resources. 

#include    <cphcltdialer.h> // cphcltdialer. 

#include    <cphonecntfactory.h> 

#include    <aiwinternaldialdata.h> 

#include    <aiwservicehandler.h> 

#include    <cphcltextphonedialdata.h> // cphcltextphonedialdata 

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

#include    <stringloader.h> // string loader. 

#include    <featmgr.h> // featuremanager. 

#include    <phcltutils.h> // character removal. 

#include    <aiwcommon.h> // aiw dialdata. 

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

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

// CCaUiEngine::CCaUiEngine

// 

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

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

//

CCaUiEngine::CCaUiEngine()

:   iResourceLoader( *CCoeEnv::Static() )

#ifndef RD_PHONE_NG

    ,iResourceLoaderPhoneApE( *CCoeEnv::Static() )

#endif    

    {

    }

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

// CCaUiEngine::ConstructL

// 

// Symbian 2nd phase constructor can leave.

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

//

void CCaUiEngine::ConstructL()

    {

    // 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 );

        }

    }

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

// 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 iContactSelector;

    delete iFactory;

    // Clear dial components.

    ClearDialContents();

    if( CCoeEnv::Static() )

        {

        // Close resource loader.

        iResourceLoader.Close();

#ifndef RD_PHONE_NG

        // Release PhoneAppEngine resources.

        iResourceLoaderPhoneApE.Close();

#endif

        }

    // Delete the menubuffer.

    delete iBuf;

    iBuf = NULL;

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

    FeatureManager::UnInitializeLib();

    }

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

// CCaUiEngine::GetResources

// 

// 

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

//

void CCaUiEngine::GetResources(

    const TCaUiEngResource aResource,

    TFileName& aResFile,

    TInt& aResId )

    {

    aResFile = KCallUIResFile;

    if ( aResource == ECaUiResOnlyInternet )

        {

        aResId = 0;

        }

    else

        {

        // Return pure voice menu item.

        aResId = R_CALLUI_CALL_MENU;

        }

    }

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

// CCaUiEngine::DialL

// 

// 

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

//

void CCaUiEngine::DialL(

    MCaUiDialResultObserver& aObserver,

    const TDesC8& aDialData,

    const TCaUiCallType aCallType )

    {

    TInt length = aDialData.Length();

    // If iPhCltDialer and iDialDataContainer 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 );

    // Convert AIW dial data to PhoneClient format.

    ConvertDialDataL( *aiwDialData );

    iDialData->SetCallType( EPhCltVoice );

    //a call type is still unknown if the dialing is made via phonebook

    //send key (doesn't use HandleMenuCmdL, check the call type in 

    //aiwDialData to make sure if unknown is really unknown

    //only do if call type unknown

    TCaUiCallType callType = aCallType;

    if ( callType == ECaUiCallTypeUnknown )

        {

        CAiwDialData::TCallType aiwCalltype = aiwDialData->CallType();

        switch ( aiwCalltype )

           {

           case CAiwDialData::EAIWVoice:

                callType = ECaUiCallTypeVoice;

                break;

            case CAiwDialData::EAIWVideo:

            case CAiwDialData::EAIWForcedVideo:

                callType = ECaUiCallTypeVideo;

                break;

            case CAiwDialData::EAIWVoiP:

                callType = ECaUiCallTypeInternet;

                break;

            default:

                //already unknown

                break;

            }

        }

    //aiwDialData not needed anymore, remove from stack

    CleanupStack::PopAndDestroy( aiwDialData );

    // If Contact link is provided fetch field link from Phone Book.

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

        {

        // Launch address select.

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

        LaunchAddressSelectL( 

                        iDialData->ContactLink(), 

                        callType );

        }

    else 

        {

        iPhCltDialer->DialL( *iDialData );

        }

    }

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

// CCaUiEngine::LaunchNoNetSupNoteL

// 

// 

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

//

void CCaUiEngine::LaunchNoNetSupNoteL()

    {

    User::Leave( KErrNotSupported );

    }

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

// CCaUiEngine::LaunchReconConfQueryL

// 

// 

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

//

void CCaUiEngine::LaunchReconConfQueryL( 

    MCaUiReconnectQueryObserver& /*aObserver*/,

    CPhCntMatcher* /*aPhCntMatcher*/,

    const TPtrC /*aPhoneNumber*/,

    const TBool /*aIncludeVideoCallOption*/ )

    {

    User::Leave( KErrNotSupported );

    }

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

// CCaUiEngine::CancelReconConfQuery

// 

// 

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

//

void CCaUiEngine::CancelReconConfQuery()

    {

    }

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

// CCaUiEngine::LaunchNoteAndReconConfQueryL

// 

// 

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

//

void CCaUiEngine::LaunchNoteAndReconConfQueryL( 

    MCaUiReconnectQueryObserver& /*aObserver*/,

    CPhCntMatcher* /*aPhCntMatcher*/,

    const TPtrC /*aPhoneNumber*/,

    const TBool /*aIncludeVideoCallOption*/,

    const TPtrC /*aNoteText*/ )

    {

    User::Leave( KErrNotSupported );

    }

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

// CCaUiEngine::CancelNoteAndReconConfQuery

// 

// 

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

//

void CCaUiEngine::CancelNoteAndReconConfQuery()

    {

    }

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

// CCaUiEngine::LaunchAddressSelectL

// 

// 

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

//

TBool CCaUiEngine::LaunchAddressSelectL( 

    TDes& aTelNum, 

    const TInt aContactId,

    const TBool aVoIPAddressSelect )

    {

    if ( aVoIPAddressSelect )

        {

        User::Leave( KErrNotSupported );

        }

    TBool addressSelected( EFalse );

    TCaUiCallType callType( ECaUiCallTypeVoice );

    addressSelected = LaunchAddressSelectL( aTelNum, aContactId, callType );

    return addressSelected;

    }

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

// CCaUiEngine::CancelAddressSelect

// 

// 

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

//

void CCaUiEngine::CancelAddressSelect()

    {

    }

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

// From MPhCntStoreLoaderObserver.

// CCaUiEngine::ContactStoreLoadingCompleted

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

//

void CCaUiEngine::ContactStoreLoadingCompleted( 

        MVPbkContactStore* /*aStore*/, TInt /*aErrorCode*/ )

    {

    }

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

// CCaUiEngine::HandleDialL

// 

// 

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

//

void CCaUiEngine::HandleDialL( const TInt aStatus )

    {

    if ( iObserver )

        {

        iObserver->HandleDialResultL( aStatus );

        }

    ClearDialContents();

    }

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

// From base class MCaUiReconnectQueryObserver

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

//   

void CCaUiEngine::OptionSelected( 

    MCaUiReconnectQueryObserver::TCaUiReconType /*aReconType*/ )

    {

    }

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

// CCaUiEngine::ConvertDialData

// 

// 

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

//

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;

    // After this the call type should be correct one.

    if ( aiwCallType == CAiwDialData::EAIWVideo )

        {

        phCltCallType = EPhCltVideo;

        iDialData->SetCallType( phCltCallType );

        }

    else if ( aiwCallType == CAiwDialData::EAIWForcedVideo )

        {

        phCltCallType = EPhCltForcedVideo;

        iDialData->SetCallType( phCltCallType );

        }

    else if ( aiwCallType == CAiwDialData::EAIWVoiP )

        {

        phCltCallType = EPhCltCallVoIP;

        iDialData->SetCallType( phCltCallType );

        }

     // Name.

    iDialData->SetNameL( aAiwDialData.Name().Left( 

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

    // Contact link.

    iDialData->SetContactLinkL( aAiwDialData.ContactLink() );

    // Window group.

    iDialData->SetWindowGroup( aAiwDialData.WindowGroup() );

    // Redial.

    iDialData->SetRedial( aAiwDialData.Redial() );

    // Redial maximum duration.

    iDialData->SetRedialMaximumDuration( aAiwDialData.RedialMaximumDuration() );

    // Show number.

    iDialData->SetShowNumber( aAiwDialData.ShowNumber() );

    // Match.

    iDialData->SetAllowMatch( aAiwDialData.AllowMatch() );

    // End other calls.

    iDialData->SetEndOtherCalls( aAiwDialData.EndOtherCalls() );

    // Subaddress.

    iDialData->SetSubAddressL( aAiwDialData.SubAddress().Left( 

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

    // SAT call.

    iDialData->SetSATCall( aAiwDialData.SATCall() );

    // Bearer.

    iDialData->SetBearerL( aAiwDialData.Bearer().Left( 

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

    TPhCltTelephoneNumber telnum;

    telnum.Zero();

    telnum = iDialData->TelephoneNumber();

    PhCltUtils::RemoveInvalidChars( telnum );

    iDialData->SetTelephoneNumber( telnum );

    }

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

// CCaUiEngine::ClearDialContents

// 

// 

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

//

void CCaUiEngine::ClearDialContents()

    {

    if ( iPhCltDialer )

        {

        delete iPhCltDialer;

        iPhCltDialer = NULL;

        }

    if ( iDialData )

        {

        delete iDialData;

        iDialData = NULL;

        }

    // Not owned, so just set to NULL.

    iObserver = NULL;

    }

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

// CCaUiEngine::LaunchAddressSelectL

// 

// 

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

//

void CCaUiEngine::LaunchAddressSelectL( 

    const TDesC8& aContactLink,

    const TCaUiCallType aCallType )

    {

    if ( aCallType != ECaUiCallTypeVoice )

        {

        HandleDialL( KErrNotSupported );

        }

    else

        {

        if ( !iFactory )

            {

            iFactory = CreateCntFactoryL();

            }

        if ( !iContactSelector ) 

            {

            iContactSelector = iFactory->CreateContactDataSelectionL();

            }

        CPhCntContactDataSelection::TCallType callType;

        if ( aCallType == ECaUiCallTypeVoice )

            {

            callType = CPhCntContactDataSelection::ECallPhoneNumber;

            }

        else if ( aCallType == ECaUiCallTypeVideo )

            {

            callType = CPhCntContactDataSelection::ECallVideoNumber;

            }

        else if ( aCallType == ECaUiCallTypeInternet )

            {

            callType = CPhCntContactDataSelection::ECallVoip;

            }

        else

            {

            callType = CPhCntContactDataSelection::ECallPhoneNumber;

            }

        iContactSelector->Cancel();

        iContactSelector->SelectPhoneNumberForCallL( aContactLink, callType, *this );

        }

    }

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

//  CCaUiEngine::HandleEmergencyDialL()

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

//    

void CCaUiEngine::HandleEmergencyDialL( const TInt /*aStatus*/ )

    {

    // Do nothing

    }