/*

* Copyright (c) 2008 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 CPhoneVoIPErrorMessagesHandler class.

*

*/

// INCLUDES

#include <ccpdefs.h>

#include <mpeengineinfo.h>

#include <StringLoader.h>

#include <ccherror.h>

#include <spsettings.h>

#include <spentry.h>

#include <telephonydomainpskeys.h>

#include <UikonInternalPSKeys.h>

#include <aknnotedialog.h>

#include "cphonevoiperrormessageshandler.h"

#include "cphonemainerrormessageshandler.h"

#include "cphoneerrormessageshandler.h"

#include "cphonestatehandle.h"

#include "phonerssvoip.h"

#include "phonelogger.h"

#include "tphonecmdparamglobalnote.h"

#include "tphonecmdparaminteger.h"

#include "cphonemainresourceresolver.h"

#include "phoneui.pan"

#include "cphonepubsubproxy.h"

#include "tphonecmdparamboolean.h"

#include "cphonestatemachinevoip.h"

#include "cphonecustomizationvoip.h"

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

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

// might leave.

//

CPhoneVoIPErrorMessagesHandler::CPhoneVoIPErrorMessagesHandler(

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneStateMachine* aPhoneStateMachine ) :

    CPhoneErrorMessagesHandler( aViewCommandHandle, aPhoneStateMachine )

    {

    static_cast<CPhoneStateMachineVoIP*>( iStateMachine )->

        SetVoipErrorMessageHandler( *this );

    }

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

// CPhoneErrorMessagesHandler::~CPhoneErrorMessagesHandler()

// Destructor

// (other items were commented in a header).

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

//

CPhoneVoIPErrorMessagesHandler::~CPhoneVoIPErrorMessagesHandler()

    {

    }

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

// CPhoneVoIPErrorMessagesHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPhoneVoIPErrorMessagesHandler::ConstructL()

    {

    // Register error handler

    CPhoneMainErrorMessagesHandler::Instance()->

        RegisterErrorMessagesHandler( this );

    }

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

// CPhoneVoIPErrorMessagesHandler::NewL()

// Constructor

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

//

CPhoneVoIPErrorMessagesHandler* CPhoneVoIPErrorMessagesHandler::NewL(

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneStateMachine* aPhoneStateMachine )

    {

    CPhoneVoIPErrorMessagesHandler* self =

        new( ELeave ) CPhoneVoIPErrorMessagesHandler(

            aViewCommandHandle,

            aPhoneStateMachine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneVoIPErrorMessagesHandler::ShowErrorSpecificNoteL

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

//

void CPhoneVoIPErrorMessagesHandler::ShowErrorSpecificNoteL( 

    const TPEErrorInfo& aErrorInfo )

    {

    __LOGMETHODSTARTEND(PhoneUIVoIPExtension, "CPhoneVoipErrorMessagesHandler::ShowErrorSpecificNoteL()");

    __PHONELOG1( EBasic, PhoneUIVoIPExtension,

            "CPhoneVoIPErrorMessagesHandler::ShowErrorSpecificNoteL - aErrorInfo.iErrorCode =%d ",

            aErrorInfo.iErrorCode);

    if ( aErrorInfo.iErrorType == EPECcp && IsVoIPCall( aErrorInfo.iCallId ) )

        {

        switch( aErrorInfo.iErrorCode )

            {

            case ECCPErrorNotAcceptable:

            case ECCPErrorCCServiceNotImplemented:

                SendGlobalErrorNoteL( EPhoneVoIPNoAudioSupport );

                break;

            case ECCPLocalResumeFail:

                if ( HasSwapFailed() )

                    {

                    SendGlobalErrorNoteL( EPhoneVoIPSwapFail );

                    }

                else

                    {

                    HandleHoldErrorNotesL( aErrorInfo.iCallId, EFalse );

                    }

                break;

            case ECCPLocalHoldFail:

                if ( HasSwapFailed() )

                    {

                    SendGlobalErrorNoteL( EPhoneVoIPSwapFail );

                    }

                else

                    {

                    HandleHoldErrorNotesL( aErrorInfo.iCallId, ETrue );

                    }

                break;

            case ECCPServerFailure:

            case ECCPErrorNetworkBusy:

                SendGlobalErrorNoteL( EPhoneVoIPNoService );

                break;

            case ECCPErrorNotReached:

                SendGlobalErrorNoteL( EPhoneVoIPNotFound );

                break;

            case ECCPErrorCCIncompatibleDestination:

                SendGlobalErrorNoteL( EPhoneVoIPAddressNotInUse );

                break;

            case ECCPErrorTimedOut:

            case ECCPErrorCCNoRouteToDestination:

                SendGlobalErrorNoteL( EPhoneVoIPRequestTimeOut );

                break;

            case KErrArgument:

            case ECCPErrorInvalidPhoneNumber:

            case ECCPErrorInvalidURI:

                SendGlobalErrorNoteL( EPhoneVoIPInvalidRecipientAddress );

                break;

            case ECCPErrorBusy:

            case ECCPErrorCCCallRejected:

                SendGlobalErrorNoteL( EPhoneVoIPNumberBusy );

                break;

            case ECCPErrorMovedPermanently:

                SendGlobalErrorNoteL( EPhoneVoIPAddressNotInUse );

                break;

            case ECCPErrorCCUserNotResponding:

            case ECCPErrorNotResponding:

                SendGlobalErrorNoteL( EPhoneVoIPNoAnswer );

                break;

            case ECCPGlobalFailure:

                SendGlobalErrorNoteL( EPhoneVoIPErrorInConnection );

                break;

            case ECCPSecureCallFailed:    

            case ECCPErrorUnacceptableChannel:

                SendGlobalErrorNoteL( EPhoneSSNotificationTextVoipSipsFailed );

                break;

            case ECCPErrorNetworkOutOfOrder:

            case ECCPErrorMedia:

                SendGlobalErrorNoteL( EPhoneVoIPNetworkError );

                break;

            case ECCPTransferFailed:

                iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveGlobalNote );

                SendGlobalErrorNoteL( EPhoneVoIPTransferFail );

                break;

            case ECCPErrorNoService:

                {

                TInt serviceID = iStateMachine->PhoneEngineInfo()->ServiceId(

                    aErrorInfo.iCallId );

                ShowErrorNoteWithServiceNameL( EPhoneVoIPServiceUnavailable,

                    serviceID );

                }

                break;

            default:

                CPhoneErrorMessagesHandler::ShowErrorSpecificNoteL( aErrorInfo );

                break;

            }

        }

    else if ( aErrorInfo.iErrorType == EPECch )

        {

        ShowRegistrationErrorNotesL( aErrorInfo.iErrorCode );   

        }

    else

        {

        CPhoneErrorMessagesHandler::ShowErrorSpecificNoteL( aErrorInfo );

        }

    }

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

// CPhoneVoipErrorMessagesHandler::IsVoIPCall

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

//

TBool CPhoneVoIPErrorMessagesHandler::IsVoIPCall( const TInt aCallId ) const

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, "CPhoneVoIPErrorMessagesHandler::IsVoipCall() ");

    if( aCallId == KErrNotFound )

        {

        // Illegal call id, check call type command

        return ( iStateMachine->PhoneEngineInfo()->CallTypeCommand()

            == EPECallTypeVoIP );

        }

    return ( iStateMachine->PhoneEngineInfo()

        ->CallType( aCallId )== EPECallTypeVoIP );

    }

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

// CPhoneVoipErrorMessagesHandler::HandleHoldErrorNotesL

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

//

void CPhoneVoIPErrorMessagesHandler::HandleHoldErrorNotesL( 

    const TInt aCallId, TBool aHold )

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, "CPhoneVoIPErrorMessagesHandler::HandleHoldNoteL()");

    TPhoneCmdParamGlobalNote globalNoteParam;

    HBufC* text = HBufC::NewLC( KPhoneContactNameMaxLength );

    TPtr tmp = text->Des();

    // Should add name( or RemotePartyName or CompanyName) to Note, if someone found

    GetRemoteInfoDataL( aCallId, tmp );

    if ( text->Length() )

        {

        // RemotePartyName, CompanyName or RemoteName found

        // Resource text which will use found text will be loaded later

        TInt resource( EPhoneVoIPResumeFail );

        if ( aHold )

            {

            resource = EPhoneVoIPHoldFail;    

            }

        // qtn_voip_resume_failed / qtn_voip_hold_failed

        globalNoteParam.SetTextResourceId(

            CPhoneMainResourceResolver::Instance()->

                ResolveResourceID( resource ) );

        }

    else

        {

        // Decides note with call id

        // Resource is loaded here

        TInt resource = EPhoneVoIPResumeNumberFail;

        if ( aHold )

            {

            resource = EPhoneVoIPHoldNumberFail;    

            }

        // qtn_voip_resume_number_failed / qtn_voip_hold_number_failed

        const TInt tmpResourceId = CPhoneMainResourceResolver::Instance()->

            ResolveResourceID( resource );

        TInt callId = aCallId;

        callId++; // Real call id index starts from 0, increase value by one

        CleanupStack::PopAndDestroy( text ); // Delete reserver buffer

        text = StringLoader::LoadLC( 

                tmpResourceId, 

                callId, 

                CCoeEnv::Static() ); // Load new buffer

        }

    globalNoteParam.SetText( *text );

    globalNoteParam.SetType( EAknGlobalConfirmationNote );

    globalNoteParam.SetTone( EAvkonSIDInformationTone );

    iViewCommandHandle->ExecuteCommandL( 

            EPhoneViewShowGlobalNote, &globalNoteParam );

    CleanupStack::PopAndDestroy( text );

    }

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

// CPhoneVoIPErrorMessagesHandler::GetRemoteInfoDataL

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

//

void CPhoneVoIPErrorMessagesHandler::GetRemoteInfoDataL( 

    TInt aCallId,

    TDes& aData ) const 

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

            "CPhoneVoIPErrorMessagesHandler::GetRemoteInfoDataL()" );

    __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),

            Panic( EPhoneCtrlInvariant ) );

    // Note next if-statements are in priority order so be careful if you change order

    // or add new if-statements.

    if ( iStateMachine->PhoneEngineInfo()->RemoteName( aCallId ).Length() )

        {

        __PHONELOG1( EBasic, PhoneUIVoIPExtension, 

            "CPhoneVoIPErrorMessagesHandler::GetRemoteInfoDataL - remote name = %S", 

            &iStateMachine->PhoneEngineInfo()->RemoteName( aCallId ) );

        if ( iStateMachine->PhoneEngineInfo()->RemoteName( aCallId ).Length()

             < KPhoneContactNameMaxLength )

            {

            // Display the contact name if it is available

            aData.Copy( iStateMachine->PhoneEngineInfo()->RemoteName( aCallId ) );

            }

        }

    else if ( iStateMachine->PhoneEngineInfo()->RemoteCompanyName( aCallId ).Length() )

         {

         __PHONELOG1( EBasic, PhoneUIVoIPExtension, 

             "CPhoneVoIPErrorMessagesHandler::GetRemoteInfoDataL - remote company name = %S", 

             &iStateMachine->PhoneEngineInfo()->RemoteCompanyName( aCallId ) );

         if ( iStateMachine->PhoneEngineInfo()->RemoteCompanyName( aCallId ).Length()

              < KPhoneContactNameMaxLength )

             {            

             // Display the company name if it is available

             aData.Copy( iStateMachine->PhoneEngineInfo()->RemoteCompanyName( aCallId ) );

             }

         }

    else if( iStateMachine->PhoneEngineInfo()->RemotePartyName( aCallId ).Length() )

        {

        __PHONELOG1( EBasic, PhoneUIVoIPExtension, 

            "CPhoneVoIPErrorMessagesHandler::GetRemoteInfoDataL - remote party name = %S", 

            &iStateMachine->PhoneEngineInfo()->RemotePartyName( aCallId ) );

        if ( iStateMachine->PhoneEngineInfo()->RemotePartyName( aCallId ).Length()

             < KPhoneContactNameMaxLength )

            {            

            // Display the remote party name if it is available

            aData.Copy( iStateMachine->PhoneEngineInfo()->RemotePartyName( aCallId ) );

            }

        }

    else

        {

        __PHONELOG( EBasic, PhoneUIVoIPExtension, 

            "CPhoneVoIPErrorMessagesHandler::GetRemoteInfoDataL - not found" );

        aData.Zero();

        }

    }

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

// CPhoneVoIPErrorMessagesHandler::ShowRegistrationErrorNotesL

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

//

void CPhoneVoIPErrorMessagesHandler::ShowRegistrationErrorNotesL( 

    TInt aErrorCode )

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

              "CPhoneVoIPErrorMessagesHandler::ShowRegistrationErrorNotesL()" );

    // Dismiss service enabling wait note

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveGlobalWaitNote );

    switch ( aErrorCode )

        {

        case KCCHErrorAccessPointNotDefined:

            {

            TUint32 serviceId = 

                iStateMachine->PhoneEngineInfo()->ServiceIdCommand();

            ShowErrorNoteWithServiceNameL( EPhoneVoIPNoConnectionsDefined,

                serviceId );

            break;

            }

        case KCCHErrorBandwidthInsufficient:   

            {

            TUint32 serviceId = 

                iStateMachine->PhoneEngineInfo()->ServiceIdCommand();

            ShowErrorNoteWithServiceNameL( EPhoneVoIPCallsNotSupported,

                serviceId );

            break;

            }

        case KCCHErrorInvalidSettings:

            {

            TUint32 serviceId = 

                iStateMachine->PhoneEngineInfo()->ServiceIdCommand();

            ShowErrorNoteWithServiceNameL( EPhoneVoIPDefectiveSettings,

                serviceId );

            break;

            }

        case KCCHErrorAuthenticationFailed:

            {

            SendGlobalErrorNoteL( EPhoneVoIPAuthenticationFailed );

            break;

            }

        case KCCHErrorInvalidIap:

        case KCCHErrorNetworkLost:

        case KCCHErrorServiceNotResponding:

            {

            TUint32 serviceId = 

                iStateMachine->PhoneEngineInfo()->ServiceIdCommand();

            ShowErrorNoteWithServiceNameL( EPhoneVoIPNoConnectionsAvailable,

                serviceId );

            break;

            }

        case KCCHErrorLoginFailed: 

        default:

            {

            TUint32 serviceId = 

               iStateMachine->PhoneEngineInfo()->ServiceIdCommand();

            ShowErrorNoteWithServiceNameL( EPhoneVoIPServiceUnavailable,

               serviceId );

            break;

            }

        }

    }

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

//  CPhoneVoIPErrorMessagesHandler::SendGlobalErrorNoteWithTextL

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

//

void CPhoneVoIPErrorMessagesHandler::SendGlobalErrorNoteWithTextL( 

    TInt aResourceId,

    RBuf& aText )

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneVoIPErrorMessagesHandler::SendGlobalErrorNoteL()" );

    __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );

    if ( CPhonePubSubProxy::Instance()->Value( 

            KPSUidUikon, KUikGlobalNotesAllowed ) == 1 )

        {

        // Re-enable global notes

        TPhoneCmdParamBoolean globalNotifierParam;

        globalNotifierParam.SetBoolean( EFalse );

        iViewCommandHandle->ExecuteCommandL( 

             EPhoneViewSetGlobalNotifiersDisabled,

            &globalNotifierParam );

        TPhoneCmdParamGlobalNote globalNoteParam;

        globalNoteParam.SetType( EAknGlobalErrorNote );

        globalNoteParam.SetTextResourceId( 

            CPhoneMainResourceResolver::Instance()->

            ResolveResourceID( aResourceId ) );

        globalNoteParam.SetText( aText );

        globalNoteParam.SetTone( CAknNoteDialog::EErrorTone );

        iViewCommandHandle->ExecuteCommandL(  

            EPhoneViewShowGlobalNote, &globalNoteParam );

        } 

    }

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

// CPhoneVoIPErrorMessagesHandler::GetServiceProviderNameL

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

//

void CPhoneVoIPErrorMessagesHandler::GetServiceProviderNameL( 

    RBuf& aServiceName, 

    TUint32 aServiceId )

    { 

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

                 "CPhoneVoIPErrorMessagesHandler::GetServiceProviderNameL" )

    CSPEntry* serviceEntry = CSPEntry::NewLC();

    CSPSettings* serviceProviderSettings = CSPSettings::NewLC();

    User::LeaveIfError(

        serviceProviderSettings->FindEntryL( aServiceId, *serviceEntry ) );

    User::LeaveIfError(

        aServiceName.Create( serviceEntry->GetServiceName() ) );

    CleanupStack::PopAndDestroy( serviceProviderSettings );

    CleanupStack::PopAndDestroy( serviceEntry );

    }

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

// CPhoneVoIPErrorMessagesHandler::ShowErrorNoteContainingServiceNameL

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

//

void CPhoneVoIPErrorMessagesHandler::ShowErrorNoteWithServiceNameL( 

    TInt aResourceId, 

    TUint32 aServiceId )

    {

    __LOGMETHODSTARTEND( PhoneUIVoIPExtension, 

        "CPhoneVoIPErrorMessagesHandler::ShowErrorNoteWithServiceNameL" )

    RBuf serviceName;

    CleanupClosePushL( serviceName );

    GetServiceProviderNameL( serviceName, aServiceId );

    SendGlobalErrorNoteWithTextL( aResourceId, serviceName );

    CleanupStack::PopAndDestroy( &serviceName );

    }

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

// CPhoneVoIPErrorMessagesHandler::HasSwapFailed

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

//

TBool CPhoneVoIPErrorMessagesHandler::HasSwapFailed() const

    {

    TPEState callState( EPEStateUnknown );

    TPECallType callType( EPECallTypeUninitialized );

    TPEState confCallState( EPEStateUnknown );

    TInt connectedCalls( 0 );

    TInt heldCalls( 0 );

    TInt voipCalls( 0 );

    TBool ret( EFalse );