/*

* 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:  Implements class CSPVoiceCall which provides call functionality

*

*/

#include <etelmm.h>

#include <etel.h>

#include <mccpcallobserver.h>

#include <cccecallparameters.h>

#include "cspvoicecall.h"

#include "cspetelcallrequester.h"

#include "cspetelcalleventmonitor.h"

#include "cspetelcallstatusmonitor.h"

#include "csplogger.h"

#include "csppanic.pan"

#include "cspconsts.h"

#include "mcspcommoninfo.h"

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

// CSPVoiceCall::NewL Two phased construction.

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

//

CSPVoiceCall* CSPVoiceCall::NewL( const TDesC& aName, 

                          RMobileLine& aLine, TBool aMobileOriginated, 

                          const CCCECallParameters& aParams,

                          MCSPCommonInfo& aCommonInfo,

                          TBool aIsEmergency )

    {

    CSPLOGSTRING(CSPOBJECT, "CSPVoiceCall::NewL <");

    CSPVoiceCall* self = new ( ELeave ) CSPVoiceCall( aLine, 

                                            aMobileOriginated,

                                            aName,

                                            aCommonInfo,

                                            aIsEmergency );

    CleanupStack::PushL( self );

    self->ConstructL( aParams );

    CleanupStack::Pop( self );

    CSPLOGSTRING(CSPOBJECT, "CSPVoiceCall::NewL >");

    return self;

    }

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

// CSPVoiceCall::~CSPVoiceCall

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

//

CSPVoiceCall::~CSPVoiceCall()

    {

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

    }

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

// CSPVoiceCall::GoOneToOneL

// Goes one to one from conference.

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

//

TInt CSPVoiceCall::GoOneToOne( )

    {

    CSPLOGSTRING(CSPREQIN, "CSPVoiceCall::GoOneToOne");

    return iRequester->MakeRequest( 

        CSPEtelCallRequester::ERequestTypeGoOneToOne );

    }

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

// From class MCCPCSCall

// CSPVoiceCall::Dial

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

//

TInt CSPVoiceCall::DialFdnCond( TBool aFdnCond )

    {

    CSPLOGSTRING(CSPREQIN, "CSPVoiceCall::DialFdnCond <");

    if ( !iMobileOriginated )

        {

        CSPLOGSTRING(CSPINT, 

                "CSPVoiceCall::DialFdnCond MT CALL, Dial not supported");

        return KErrNotSupported;

        }

    CSPLOGSTRING(CSPINT, "CSPVoiceCall::DialFdnCond making request");

    SetDefaultCallParameters();

    iCommonInfo.InitializeCallParameters( iCallParams );

    iCallParams.iSubAddress = iParams->SubAddress();

    iCallParams.iBearerCap1 = iParams->Bearer();

    if ( CCCECallParameters::ECCECallOriginSAT == iParams->Origin() )

        {

        iCallParams.iCallParamOrigin = RMobileCall::EOriginatorSIM;

        }

    TInt err(KErrNone);

    if ( aFdnCond )

        {

        err = iRequester->MakeDialRequest( iCallParamsPckg, iRemotePartyNumber );

        }

    else

        {

        err = iRequester->MakeDialNoFdnCheckRequest( 

                        iCallParamsPckg, iRemotePartyNumber );

        }

    CSPLOGSTRING2(CSPINT, "CSPVoiceCall::DialFdnCond > res: %d", err );

    return err;    

    }

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

// Make the DialEmergencyCall request to ETel ( impl. of MCCPEmergencyCall )

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

//

TInt CSPVoiceCall::Dial( const TDesC& aEmergencyNumber )

    {    

    CSPLOGSTRING2(CSPREQIN, "CSPVoiceCall::Dial EMERGENCY %S", &aEmergencyNumber);

    iDialCompletionCode = KErrNone;

    iTerminationErrorNotified = EFalse;

    iIsEmergencyCall = ETrue;

    iEmergencyNumber.Zero(); 

    TInt emergencyNumberLength = aEmergencyNumber.Length(); 

    if ( emergencyNumberLength > 0 && 

        emergencyNumberLength <= RMobileENStore::KEmergencyNumberSize )

        {

        iEmergencyNumber.Append( aEmergencyNumber );

        }

    else if ( emergencyNumberLength > RMobileENStore::KEmergencyNumberSize )

        {                

        CSPLOGSTRING(CSPERROR, "CSPVoiceCall::Dial invalid argument" );

        return KErrArgument; 

        }

    CSPLOGSTRING2(CSPREQIN, "CSPVoiceCall::Dial using %S", &iEmergencyNumber);

    TInt err( iRequester->MakeDialEmergencyRequest( iEmergencyNumber ) );

    CSPLOGSTRING2(CSPINT, "CSPVoiceCall::Dial res %d", err );

    return err;

    }

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

// From class MCCPCall

// CSPVoiceCall::Answer

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

//

TInt CSPVoiceCall::Answer()

    {

    CSPLOGSTRING(CSPREQIN, "CSPVoiceCall::Answer");    

    return CSPCall::Answer();

    }

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

// From class MCCPCall

// CSPCall::HangUp

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

//

TInt CSPVoiceCall::HangUp()

    {

    CSPLOGSTRING(CSPREQIN, "CSPVoiceCall::HangUp");    

    return CSPCall::HangUp();   

    }

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

// From class MCCPCall

// CSPVoiceCall::Cancel

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

//

TInt CSPVoiceCall::Cancel()

    {

    CSPLOGSTRING(CSPREQIN, "CSPVoiceCall::Cancel");    

    return CSPCall::Cancel();

    }

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

// From class MCCPCSCall

// CSPVoiceCall::SwitchAlternatingCall

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

//

TInt CSPVoiceCall::SwitchAlternatingCall()

    {

    CSPLOGSTRING(CSPERROR, "CSPVoiceCall::SwitchAlternatingCall not supported!");

    return KErrNotSupported;

    }

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

// CSPVoiceCall::CSPVoiceCall

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

//

CSPVoiceCall::CSPVoiceCall( RMobileLine& aLine, 

                  TBool aMobileOriginated,

                  const TDesC& aName,

                  MCSPCommonInfo& aCommonInfo,

                  TBool aIsEmergency ):CSPCall( aLine,

                     aMobileOriginated, aName, 

                     aCommonInfo, aIsEmergency ),

                     iCallParams(),

                     iCallParamsPckg (iCallParams)

    {

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

    }

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

// CSPVoiceCall::ConstructL

// Constructing CSPVoiceCall for MT call.

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

//    

void CSPVoiceCall::ConstructL( const CCCECallParameters& aParams )

    {

    CSPLOGSTRING(CSPOBJECT, "CSPVoiceCall::ConstructL <");

    CSPCall::ConstructL( aParams );

    CSPLOGSTRING(CSPOBJECT, "CSPVoiceCall::ConstructL >");

    }

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

// CSPVoiceCall::SetDefaultCallParameters

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

//

void CSPVoiceCall::SetDefaultCallParameters()

    {

    CSPLOGSTRING(CSPOBJECT, "CSPVoiceCall::SetDefaultCallParameters");

    //Set defaults

    iCallParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOn;

    iCallParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeMedium;

    iCallParams.iInterval = KCSPDefaultInterval;

    iCallParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;

    iCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

    iCallParams.iAutoRedial = KCSPDefaultAutoRedial;

    }

// End of File