/*

* Copyright (c) 2007 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 

*                CSPEtelConferenceCallRequester.

*

*/

#include <etelmm.h>

#include <mccpconferencecallobserver.h>

#include "cspetelconferencecallrequester.h"

#include "csplogger.h"

#include "cspconferencecall.h"

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

// Constructs the requester via two phased constructing.

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

//

CSPEtelConferenceCallRequester* CSPEtelConferenceCallRequester::NewL(

            CSPConferenceCall& aOwner,

            RMobileConferenceCall& aCall ) 

    {

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

    CSPEtelConferenceCallRequester* self = new ( ELeave ) CSPEtelConferenceCallRequester( 

                                        aOwner, aCall );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor of the object.

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

//

CSPEtelConferenceCallRequester::~CSPEtelConferenceCallRequester( )

    {

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

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

    Cancel();

    }

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

// CSPEtelConferenceCallRequester::MakeAddCallRequest

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

//

TInt CSPEtelConferenceCallRequester::MakeAddCallRequest( const TName& aCallName )

    {

    if ( !IsActive() )

        {

        iRequestType = EConferenceRequestTypeAddCall;

        iCall.AddCall( iStatus, aCallName );

        SetActive();

        }

    else

        {

        return KErrInUse;

        }

    return KErrNone;

    }

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

// CSPEtelConferenceCallRequester::MakeRequest

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

//

TInt CSPEtelConferenceCallRequester::MakeRequest( 

                                        TConferenceRequestType aRequest )

    {

    TInt result = KErrUnknown;

    if ( !IsActive() )

        {

        if ( aRequest != EConferenceRequestTypeAddCall )

            {

            iRequestType = aRequest;

            }

        CSPLOGSTRING2( CSPREQOUT, 

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

        switch ( aRequest )

            {

            case EConferenceRequestTypeAddCall:

                {

                // Requested through EConferenceRequestTypeAddCall as a special case because

                // of the parameters.

                result = KErrNotSupported;

                break;

                }

            case EConferenceRequestTypeHangup:

                {

                iCall.HangUp( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            case EConferenceRequestTypeHold:

                {

                iCall.Swap( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            case EConferenceRequestTypeResume:

                {

                iCall.Swap( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            case EConferenceRequestTypeCreateConference:

                {

                iCall.CreateConference( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            case EConferenceRequestTypeSwap:

                {

                iCall.Swap( iStatus );

                SetActive();

                result = KErrNone;

                break;

                }

            default:

                {

                CSPLOGSTRING2( CSPERROR, 

                    "CSP: CSPEtelConferenceCallRequester::MakeRequest: Unspecified \

                                        request type: %d", iRequestType );

                result = KErrArgument;

                }

            }

        }

    else

        {

        CSPLOGSTRING( CSPERROR, 

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

        if ( aRequest == EConferenceRequestTypeHangup )

            {

            // First cancel ongoing request.

            Cancel();

            iCall.HangUp( iStatus );

            SetActive();

            result = KErrNone;            

            }

        else

            {

            result = KErrInUse;

            }

        }

    return result;

    }

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

// CSPEtelConferenceCallRequester::RunL

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

//

void CSPEtelConferenceCallRequester::RunL()

    {

    // from CActive

    CSPLOGSTRING2( CSPREQEND, 

        "CSP: CSPEtelConferenceCallRequester::RunL: status: %d", iStatus.Int() );

    if ( iStatus == KErrNone )

        {

        switch ( iRequestType )

            {

            case EConferenceRequestTypeAddCall:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Add call request OK" );

                break;

                }

            case EConferenceRequestTypeHangup:

                {

                CSPLOGSTRING( CSPINT, 

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

                break;

                }

            case EConferenceRequestTypeHold:

                {

                CSPLOGSTRING( CSPINT, 

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

                break;

                }

            case EConferenceRequestTypeResume:

                {

                CSPLOGSTRING( CSPINT, 

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

                break;

                }

            case EConferenceRequestTypeCreateConference:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Conference create request OK" );

                break;

                }

            case EConferenceRequestTypeSwap:

                {

                CSPLOGSTRING( CSPINT, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Conference swap request OK" );

                break;

                }

            default:

                {

                CSPLOGSTRING2( CSPERROR, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Unspecified request \

                                                type: %d", iRequestType );

                break;

                }

            }

        }

    else

        {

        // Error situations 

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

                                completed with error: %d", iStatus.Int() );

        switch ( iRequestType )

            {

            case EConferenceRequestTypeAddCall:

                {

                CSPLOGSTRING( CSPERROR, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Add call request" );

                iOwner.NotifyConferenceError( 

                           ECCPConferenceErrorAddCall );

                break;

                }

            case EConferenceRequestTypeHangup:

                {

                CSPLOGSTRING( CSPERROR, 

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

                iOwner.NotifyConferenceError( 

                           ECCPConferenceErrorHangUp );

                break;

                }

            case EConferenceRequestTypeHold:

                {

                CSPLOGSTRING( CSPERROR, 

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

                iOwner.NotifyConferenceError( 

                           ECCPConferenceErrorHold );

                break;

                }

            case EConferenceRequestTypeResume:

                {

                CSPLOGSTRING( CSPERROR, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Resume request err" );

                iOwner.NotifyConferenceError( 

                           ECCPConferenceErrorResume );

                break;

                }

            case EConferenceRequestTypeCreateConference:

                {

                CSPLOGSTRING( CSPERROR, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Conference create request" );

                iOwner.NotifyConferenceError( 

                           ECCPConferenceErrorAddCall );

                break;

                }

            case EConferenceRequestTypeSwap:

                {

                CSPLOGSTRING( CSPERROR, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Conference swap request" );

                iOwner.NotifyConferenceError( 

                           ECCPConferenceErrorSwap );

                break;

                }

            default:

                {

                CSPLOGSTRING2( CSPERROR, 

                    "CSP CSPEtelConferenceCallRequester::RunL: Unspecified request \

                                                type: %d", iRequestType );

                break;

                }

            }

        }    

    }

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

// CSPEtelConferenceCallRequester::DoCancel

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

//

void CSPEtelConferenceCallRequester::DoCancel()

    {

    if ( IsActive() )

        {

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

        switch ( iRequestType )

            {

            case EConferenceRequestTypeAddCall:

                {

                iCall.CancelAsyncRequest( EMobileConferenceCallAddCall );

                break;

                }

            case EConferenceRequestTypeHangup:

                {

                iCall.CancelAsyncRequest( EMobileConferenceCallHangUp );

                break;

                }

            case EConferenceRequestTypeHold:

            case EConferenceRequestTypeResume:

                {

                iCall.CancelAsyncRequest( EMobileConferenceCallSwap );

                break;

                }

            case EConferenceRequestTypeCreateConference:

                {

                iCall.CancelAsyncRequest( EMobileConferenceCallCreateConference );

                break;

                }

            case EConferenceRequestTypeSwap:

                {

                iCall.CancelAsyncRequest( EMobileConferenceCallSwap );

                break;

                }

            default:

                {

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

                                Unspecified request type: %d", iRequestType );

                }

            }

        }

    else

        {

        CSPLOGSTRING( CSPERROR, 

            "CSP: CSPEtelConferenceCallRequester::DoCancel: Already active" );

        }

    }

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

// Constructs the requester.

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

//

CSPEtelConferenceCallRequester::CSPEtelConferenceCallRequester(

            CSPConferenceCall& aOwner,

            RMobileConferenceCall& aCall ) : 

                CActive( EPriorityStandard ), 

                iOwner( aOwner ), 

                iCall ( aCall )

    {

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

    CActiveScheduler::Add( this );

    }

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

// Constructing in the second phase.

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

//

void CSPEtelConferenceCallRequester::ConstructL()

    {

    }

// End of File