/*

* Copyright (c) 2007-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:  Contains the implementation of class CSPEtelCallRequester

*

*/

#include "cspetelcallrequester.h"

#include <exterror.h>

#include <gsmerror.h>

#include <etelmmerr.h>

#include <etelsat.h>

#include "mcspcallerrorobserver.h"

#include "csplogger.h"

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

// Constructs the requester via two phased constructing.

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

//

CSPEtelCallRequester* CSPEtelCallRequester::NewL(

            MCSPCallErrorObserver& aObserver,

            RMobileCall& aCall ) 

    {

    CSPLOGSTRING(CSPOBJECT, "CSPEtelCallRequester::NewL()" );

    CSPEtelCallRequester* self = new ( ELeave ) CSPEtelCallRequester( 

                                        aObserver, aCall );

    return self;

    }

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

// Destructor of the object.

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

//

CSPEtelCallRequester::~CSPEtelCallRequester( )

    {

    CSPLOGSTRING(CSPOBJECT, "CSPEtelCallRequester::~CSPEtelCallRequester()" );

    CSPLOGSTRING2(CSPINT, "CSPEtelCallRequester:: type: %d", iRequestType );

    Cancel();

    }

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

// CSPEtelCallRequester::MakeDialRequest

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

//

TInt CSPEtelCallRequester::MakeDialRequest( 

            const TDesC8& aCallParams, 

    {

    CSPLOGSTRING(CSPINT, "CSPEtelCallRequester::MakeDialRequest" );

    iRequestType = ERequestTypeDial;

    if ( !IsActive() )

        {

        iCall.Dial( iStatus, aCallParams, aRecipient );

        SetActive();

        }

    else

        {

        return KErrInUse;

        }

    return KErrNone;

    }

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

// CSPEtelCallRequester::MakeDialNoFdnCheckRequest

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

//

TInt CSPEtelCallRequester::MakeDialNoFdnCheckRequest( 

            const TDesC8& aCallParams, 

    {

    CSPLOGSTRING(CSPINT, "CSPEtelCallRequester::MakeDialNoFdnCheckRequest" );

    iRequestType = ERequestTypeDial;

    if ( !IsActive() )

        {

        iCall.DialNoFdnCheck( iStatus, aCallParams, aRecipient );

        SetActive();

        }

    else

        {

        return KErrInUse;

        }

    return KErrNone;

    }

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

// CSPEtelCallRequester::MakeAnswerRequest

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

//

TInt CSPEtelCallRequester::MakeAnswerRequest(

            const TDesC8& aCallParams )

    {

    CSPLOGSTRING(CSPINT, "CSPEtelCallRequester::MakeAnswerRequest" );

    if ( !IsActive() )

        {

        iRequestType = ERequestTypeAnswer;

        iCall.AnswerIncomingCall( iStatus, aCallParams );

        SetActive();

        }

    else

        {

        return KErrInUse;

        }

    return KErrNone;

    }

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

// CSPEtelCallRequester::MakeDialEmergencyRequest

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

//

TInt CSPEtelCallRequester::MakeDialEmergencyRequest( 

                            const RMobileENStore::TEmergencyNumber& aRecipient )

    {

    CSPLOGSTRING(CSPINT, "CSPEtelCallRequester::MakeDialEmergencyRequest" );

    Cancel();

    iRequestType = ERequestTypeDialEmergency;

    iCall.DialEmergencyCall( iStatus, aRecipient );

    SetActive();

    return KErrNone;

    }

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

// CSPEtelCallRequester::MakeRequest

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

//

TInt CSPEtelCallRequester::MakeRequest( TRequestType aRequest )

    {

    TInt result = KErrUnknown;

    if ( !IsActive() )

        {

        if ( aRequest != ERequestTypeDial 

             && aRequest != ERequestTypeDialEmergency )

            {

            iRequestType = aRequest;

            }

        CSPLOGSTRING2( CSPREQOUT, 

            "CSP: CSPEtelCallRequester::MakeRequest %d", iRequestType );

        switch ( aRequest )

            {

            case ERequestTypeDial:

                {

                // Requested through MakeDialRequest as a special case because

                // of the parameters.

                result = KErrNotSupported;

                break;

                }

            case ERequestTypeDialEmergency:

                {

                // Requested through MakeDialEmergencyRequest as a special case because

                // of the parameters.

                result = KErrNotSupported;

                break;

                }

            case ERequestTypeAnswer:

                {

                iCall.AnswerIncomingCall( iStatus );

                result = KErrNone;

                SetActive();

                break;

                }                

            case ERequestTypeHangup:

                {

                iCall.HangUp( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            case ERequestTypeHold:

                {

                iCall.Hold( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            case ERequestTypeResume:

                {

                iCall.Resume( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            case ERequestTypeGoOneToOne:

                {

                iCall.GoOneToOne( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            case ERequestTypeSwap:

                {

                iCall.Swap( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            default:

                {

                CSPLOGSTRING2( CSPERROR, 

                    "CSP: CSPEtelCallRequester::MakeRequest: Unspecified \

                                        request type: %d", iRequestType );

                result = KErrArgument;

                }

            }        

        }

    else

        {

        CSPLOGSTRING( CSPERROR, 

            "CSP: CSPEtelCallRequester::MakeRequest: Already active" );

        result = KErrInUse;

        }

    return result;

    }

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

// CSPEtelCallRequester::CancelRequest

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

//

TInt CSPEtelCallRequester::CancelRequest( TRequestType aRequest )

    {

    TInt result(KErrNone);

    if ( iRequestType == aRequest )

        {

        Cancel();

        }

    else

        {

        CSPLOGSTRING3( CSPERROR, "CSPEtelCallRequester::CancelRequest: No such active, current is %d, param=%d", iRequestType, aRequest );

        result = KErrNotReady;

        }

    return result;

    }

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

// From CActive

// CSPEtelCallRequester::RunL

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

//

void CSPEtelCallRequester::RunL()

    {

    CSPLOGSTRING2( CSPREQEND, "CSPEtelCallRequester::RunL: status: %d", iStatus.Int() );

    TRequestType endedRequest = iRequestType;

    iRequestType = ERequestTypeNone;

    if ( iStatus == KErrNone )

        {

        switch ( endedRequest )

            {            

            case ERequestTypeDial:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Dial request OK" );

                break;

                }

            case ERequestTypeAnswer:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Answer request OK" );

                break;

                }

            case ERequestTypeHangup:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Hangup request OK" );

                break;

                }

            case ERequestTypeHold:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Hold request OK" );

                break;

                }

            case ERequestTypeResume:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Resume request OK" );

                break;

                }

            case ERequestTypeGoOneToOne:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: GoOneToOne request OK" );

                break;

                }

            case ERequestTypeSwap:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Swap request OK" );

                break;

                }

            case ERequestTypeDialEmergency:

                {

                CSPLOGSTRING( CSPINT,

                "CSP CSPEtelCallRequester::RunL: DialEmergency request OK" );

                break;

                }

            default:

                {

                CSPLOGSTRING2( CSPERROR, 

                    "CSP CSPEtelCallRequester::RunL: Unspecified request \

                                                type: %d", iRequestType );

                break;

                }

            }

        }

    else

        {

        // Error situations

        TInt err = iStatus.Int();

        CSPLOGSTRING2( CSPERROR, "CSP CSPEtelCallRequester::RunL: request \

                                completed with error: %d", err );

        switch ( endedRequest )

            {

            case ERequestTypeDial:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Dial request" );

                if ( err != KErrCancel )

                    {

                    iObserver.DialRequestFailed( err );

                    return; // In case of Idle state has caused

                    // immediate destruction of this object.

                    }

                break;

                }

            case ERequestTypeAnswer:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Answer request" );

                iObserver.NotifyErrorOccurred( ECCPRequestFailure );

                break;

                }

            case ERequestTypeHangup:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Hangup request" );

                iObserver.NotifyErrorOccurred( ECCPRequestFailure );

                break;

                }

            case ERequestTypeHold:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Hold request" );

                iObserver.NotifyErrorOccurred( ECCPLocalHoldFail );

                break;

                }

            case ERequestTypeResume:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Resume request" );

                iObserver.NotifyErrorOccurred( ECCPLocalResumeFail );

                break;

                }

            case ERequestTypeGoOneToOne:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: GoOneToOne request" );

                iObserver.NotifyErrorOccurred( ECCPRequestFailure );

                break;

                }

            case ERequestTypeSwap:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelCallRequester::RunL: Swap request" );

                iObserver.NotifyErrorOccurred( ECCPRequestFailure );

                break;

                }

            case ERequestTypeDialEmergency:

                {

                CSPLOGSTRING2( CSPINT,

                    "CSP CSPEtelCallRequester: RunL: DialEmergency error: %d",

                     err );

                if ( err != KErrCancel )

                    {

                    iObserver.EmergencyDialRequestFailed(err);

                    }

                break;

                }

            default:

                {

                CSPLOGSTRING2( CSPERROR, 

                    "CSP CSPEtelCallRequester::RunL: Unspecified request \

                                                type: %d", iRequestType );

                break;

                }

            }

        }    

    }

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

// From CActive

// CSPEtelCallRequester::DoCancel

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

//

void CSPEtelCallRequester::DoCancel()

    {

    CSPLOGSTRING( CSPREQOUT, "CSP: CSPEtelCallRequester::DoCancel" );

    TRequestType cancelRequest = iRequestType;

    iRequestType = ERequestTypeNone;

    if ( IsActive() )

        {

        CSPLOGSTRING( CSPREQOUT, "CSP: CSPEtelCallRequester::DoCancel IsActive" );

        switch ( cancelRequest )

            {

            case ERequestTypeDial:

                {

                CSPLOGSTRING( CSPREQOUT, "CSPEtelCallRequester::DoCancel DialCancel" );

                iCall.DialCancel();

                CSPLOGSTRING( CSPREQOUT, "CSPEtelCallRequester::DoCancel DialCancel OK" );

                break;

                }

            case ERequestTypeAnswer:

                {

                iCall.AnswerIncomingCallCancel();

                break;

                }

            case ERequestTypeHangup:

                {

                iCall.HangUpCancel();

                break;

                }

            case ERequestTypeHold:

                {

                iCall.CancelAsyncRequest( EMobileCallHold );

                break;

                }

            case ERequestTypeResume:

                {

                iCall.CancelAsyncRequest( EMobileCallResume );

                break;

                }

            case ERequestTypeGoOneToOne:

                {

                iCall.CancelAsyncRequest( EMobileCallGoOneToOne );

                break;

                }

            case ERequestTypeSwap:

                {

                iCall.CancelAsyncRequest( EMobileCallSwap );

                break;

                }

            case ERequestTypeDialEmergency:

                {

                iCall.CancelAsyncRequest( EMobileCallDialEmergencyCall );

                break;

                }

            default:

                {

                CSPLOGSTRING2( CSPERROR, "CSP CSPEtelCallRequester::DoCancel: \

                                Unspecified request type: %d", iRequestType );

                }

            }

        }

    else

        {

        CSPLOGSTRING( CSPERROR, 

            "CSP: CSPEtelCallRequester::DoCancel: Not active" );

        }    

    }

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

// Constructs the requester.

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

//

CSPEtelCallRequester::CSPEtelCallRequester(

            MCSPCallErrorObserver& aObserver,

            RMobileCall& aCall ) : 

                CActive( EPriorityStandard ), 

                iObserver( aObserver ), 

                iCall ( aCall ),

                iRequestType( ERequestTypeNone )

    {

    CSPLOGSTRING(CSPOBJECT, "CSPEtelCallRequester::CSPEtelCallRequester()" );

    CActiveScheduler::Add( this );

    }

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

// Error value mapping.

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

//

TCCPError CSPEtelCallRequester::MapError( TInt aErrorCode )

    {

    TCCPError ret = ECCPRequestFailure;

    CSPLOGSTRING2( CSPINT, "CSPEtelCallRequester::MapError %d", aErrorCode);

    switch ( aErrorCode )

        {

        case KErrGsmCCUnassignedNumber:

            {

            ret = ECCPErrorNotReached;

            break;

            }        

        case KErrGsmCCUserBusy:

            {

            ret = ECCPErrorBusy;

            break;

            }

        case KErrMMEtelCallForbidden: