/*

* 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 CPhoneStateMachineGSM class.

*

*/

// INCLUDE FILES

#include <cpephonemodelif.h>

#include "cphonestatemachinegsm.h"

#include "phonelogger.h"

#include "phonestatedefinitions.h"

#include "phonestatedefinitionsgsm.h"

#include "cphonecallsetup.h"

#include "cphonealerting.h"

#include "cphonesinglecall.h"

#include "cphonesingleandcallsetup.h"

#include "cphonesingleandalerting.h"

#include "cphonesingleandwaiting.h"

#include "cphonetwosingles.h"

#include "cphoneconference.h"

#include "cphoneconferenceandcallsetup.h"

#include "cphoneconferenceandsingle.h"

#include "cphoneconferenceandwaiting.h"

#include "cphonesingleandcallsetupandwaiting.h"

#include "cphonecallsetupandwaiting.h"

#include "cphonetwosinglesandwaiting.h"

#include "cphoneconferenceandsingleandwaiting.h"

#include "cphoneemergency.h"

#include "cphoneconferenceandwaitingandcallsetup.h"

#include "cphoneidle.h"

#include "cphonestartup.h"

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

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

// CPhoneStateMachineGSM::CPhoneStateMachineGSM

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

// might leave.

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

//

EXPORT_C CPhoneStateMachineGSM::CPhoneStateMachineGSM(

    MPhoneViewCommandHandle* aViewCommandHandle ) :

    CPhoneStateMachine( aViewCommandHandle )

    {

    }

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

// CPhoneStateMachineGSM::~CPhoneStateMachineGSM()

// Destructor

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

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

//

EXPORT_C CPhoneStateMachineGSM::~CPhoneStateMachineGSM()

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneStateMachineGSM::~CPhoneStateMachineGSM() ");

    if( iEmergencyState )

    Dll::FreeTls();

    }

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

// CPhoneStateMachineGSM::State

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

EXPORT_C MPhoneState* CPhoneStateMachineGSM::State()

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneStateMachineGSM::State() ");

    __PHONELOG1( EBasic, EPhoneUIStates,

            "CPhoneStateMachineGSM::State() = %d ", iNewStateId );

    TBool madeStateTransition = EFalse;

    TBool deleteOldState( ETrue );

    TInt err( KErrNone );

    if( iOldStateId != iNewStateId )

        {

        if( iOldStateId == EPhoneStateIdle ||

            iOldStateId == EPhoneStateEmergency )

            {

            deleteOldState = EFalse;

            }

        if ( deleteOldState )

            {

            // Possible that derived class has been deleted iState,

            // so this delete statement may be useless.

            delete iState;

            }

        // State transition need to be made - construct new state and

        // destruct old

        switch( iNewStateId )

            {

            case EPhoneStateCallSetup:

                TRAP( err, iState = CPhoneCallSetup::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateAlerting:

                TRAP( err, iState = CPhoneAlerting::NewL(

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateSingle:

                TRAP( err, iState = CPhoneSingleCall::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateWaitingInSingle:

                TRAP( err, iState = CPhoneSingleAndWaiting::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateTwoSingles:

                TRAP( err, iState = CPhoneTwoSingles::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateCallSetupInSingle:

                TRAP( err, iState = CPhoneSingleAndCallSetup::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateAlertingInSingle:

                TRAP( err, iState = CPhoneSingleAndAlerting::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateConference:

                TRAP( err, iState = CPhoneConference::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateConferenceAndCallSetup:

                TRAP( err, iState = CPhoneConferenceAndCallSetup::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateConferenceAndSingle:

                TRAP( err, iState = CPhoneConferenceAndSingle::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateConferenceAndWaiting:

                TRAP( err, iState = CPhoneConferenceAndWaiting::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateSingleAndCallSetupAndWaiting:

                TRAP( err, iState = CPhoneSingleAndCallSetupAndWaiting::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateCallSetupAndWaiting:

                TRAP( err, iState = CPhoneCallSetupAndWaiting::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateTwoSinglesAndWaiting:

                TRAP( err, iState = CPhoneTwoSinglesAndWaiting::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateConferenceAndSingleAndWaiting:

                TRAP( err, iState = CPhoneConferenceAndSingleAndWaiting::NewL( 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateEmergency:

                if( !iEmergencyStateConstructed )

                static_cast< CPhoneEmergency* >( iEmergencyState )->

                    SetStartupInterrupted( iOldStateId == EPhoneStateStartup );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateConferenceAndWaitingAndCallSetup:

                TRAP( err, iState = 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateIdle:

                    if( !iEmergencyStateConstructed )

                madeStateTransition = ETrue;

                break;

            case EPhoneStateIncoming:

                TRAP( err, iState = 

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            case EPhoneStateStartup:

                __ASSERT_ALWAYS( KErrNone == err, User::Invariant() );

                madeStateTransition = ETrue;

                break;

            default:

                iState = CPhoneStateMachine::State();

                break;

            }

        }

    if ( madeStateTransition )

        {

        __PHONELOGSTATECHANGE( iOldStateId, iNewStateId );

        iOldStateId = iNewStateId;

        }

    return iState;

    }

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

// CPhoneStateMachineGSM::NewL()

// Constructor

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

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

//

CPhoneStateMachineGSM* CPhoneStateMachineGSM::NewL(

    MPhoneViewCommandHandle* aViewCommandHandle ) 

    {

    __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneStateMachineGSM::NewL() ");

    CPhoneStateMachineGSM* self = 

        new (ELeave) CPhoneStateMachineGSM( aViewCommandHandle );

    return self;

    }

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

// CPhoneStateMachineGSM::CreatePhoneEngineL

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

//

EXPORT_C MPEPhoneModel* CPhoneStateMachineGSM::CreatePhoneEngineL( 

    MEngineMonitor& aEngineMonitor )

    {

    return CPEPhoneModelIF::CreateL( aEngineMonitor );

    }

// End of File