/*

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

    }

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

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

    for ( TInt i=0; i < KPEMaximumNumberOfVoiceCalls; i++ )

        {

        callState = iStateMachine->PhoneEngineInfo()->CallState( i );

        callType = iStateMachine->PhoneEngineInfo()->CallType( i );

        if ( EPEStateConnected == callState )

            {

            connectedCalls++;

            if ( EPECallTypeVoIP == callType )

                {

                voipCalls++;

                }

            }

        else if ( EPEStateHeld == callState )

            {

            heldCalls++;

            if ( EPECallTypeVoIP == callType )

                {

                voipCalls++;

                }

            }

        }

    confCallState = iStateMachine->PhoneEngineInfo()->CallState( KPEConferenceCallID );

    // At least one of the calls is VoIP call (conference or single)

    if ( voipCalls )

        {

        if ( EPEStateConferenceIdle == confCallState )

            {

            // Look for connected/hold and hold/hold combinations

            if ( ( 1 == connectedCalls && 1 == heldCalls ) ||

                   2 == heldCalls )

                {

                ret = ETrue;

                }

            }

        /* Check scenario that the other call is conference

         * 1) Putting VoIP call on hold fails, as a result there is a single connected 

         *    call and conference is on hold

         * 2) Resuming VoIP call fails, all calls are on hold (because conference is 

         *    first put on hold successfully)

         */

        else if ( ( 1 == connectedCalls && EPEStateHeldConference == confCallState ) ||

                 ( 0 == connectedCalls && EPEStateHeldConference == confCallState ) )

            {

            ret = ETrue;

            }

        }

    __PHONELOG1( EBasic, PhoneUIVoIPExtension, "CPhoneVoIPErrorMessagesHandler::HasSwapFailed() returned %D", ret );

    return ret;

    }