/*

* Copyright (c) 2004-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 CStartupAdaptationStub class.

*

*/

// INCLUDE FILES

#include "StartupAdaptationStub.h"

#include "CommandProcessingEngine.h"

#include "StartupAdaptationStubModel.h"

#include "sastubeventlistener.h"

#include "StartupAdaptationStubDebug.h"

#include <startupadaptationobserver.h>

using namespace StartupAdaptation;

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

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

// CStartupAdaptationStub::NewL

// Two-phased constructor.

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

//

CStartupAdaptationStub* CStartupAdaptationStub::NewL( TAny* aConstructionParameters )

    {

    RDEBUG( _L( "CStartupAdaptationStub::NewL." ) );

    CStartupAdaptationStub* self =

        new( ELeave ) CStartupAdaptationStub(

            static_cast<MStartupAdaptationObserver*>( aConstructionParameters ) );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    RDEBUG( _L( "CStartupAdaptationStub::NewL finished." ) );

    return self;

    }

// Destructor

CStartupAdaptationStub::~CStartupAdaptationStub()

    {

    RDEBUG( _L( "CStartupAdaptationStub::~CStartupAdaptationStub." ) );

    delete iEventListener;

    delete iModel;

    delete iEngine;

    RDEBUG( _L( "CStartupAdaptationStub::~CStartupAdaptationStub finished." ) );

    }

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

// CStartupAdaptationStub::CommandL

//

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

//

void CStartupAdaptationStub::CommandL(

    const TCommand aCommandId,

    TDesC8& /*aData*/ )

    {

    RDEBUG_1( _L( "CStartupAdaptationStub::CommandL( %d )." ), aCommandId );

    TInt duration = iModel->GetDurationForNextCall( aCommandId );

    iEngine->ExecuteCommandL( aCommandId, duration );

    RDEBUG( _L( "CStartupAdaptationStub::CommandL finished." ) );

    }

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

// CStartupAdaptationStub::CommandL

//

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

//

void CStartupAdaptationStub::CancelCommandL(

    const TCommand /*aCommandId*/ )

    {

    RDEBUG( _L( "CStartupAdaptationStub::CancelCommandL." ) );

    iEngine->Cancel();

    RDEBUG( _L( "CStartupAdaptationStub::CancelCommandL finished." ) );

    }

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

// CStartupAdaptationStub::Version

//

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

//

TVersion CStartupAdaptationStub::Version() const

    {

    return TVersion( 0, 1, 0 );

    }

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

// CStartupAdaptationStub::CommandProcessedL

//

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

//

void CStartupAdaptationStub::CommandProcessedL(

    const TInt aCommandId )

    {

    RDEBUG_1( _L( "CStartupAdaptationStub::CommandProcessedL( %d )." ), aCommandId );

    switch ( aCommandId )

        {

        case EGlobalStateChange:

            {

            TResponsePckg responsePckg(

                iModel->GetGlobalStateChangeResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EExecuteSelftests:

            {

            TResponsePckg responsePckg( iModel->GetSelftestResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EValidateRTCTime:

            {

            TResponsePckg responsePckg(

                iModel->GetRTCTimeValidityResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case ESetWakeupAlarm:

            {

            TResponsePckg responsePckg( iModel->GetSetAlarmResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case ECancelWakeupAlarm:

            {

            TResponsePckg responsePckg( KErrNone );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EExecuteReset:

            {

            TResponsePckg responsePckg( iModel->GetResetResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EExecuteShutdown:

            {

            TResponsePckg responsePckg( iModel->GetShutdownResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EExecuteDOSRfs:

            {

            TResponsePckg responsePckg( iModel->GetRFSResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EGetSimChanged:

            {

            TBooleanResponse response;

            iModel->GetSimChangedResponse( response );

            TBooleanResponsePckg responsePckg( response );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EGetSimOwned:

            {

            TBooleanResponse response;

            iModel->GetSimOwnedResponse( response );

            TBooleanResponsePckg responsePckg( response );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case ESecurityStateChange:

            {

            TSecurityStateResponse response;

            iModel->GetSecurityStateChangeResponse( response );

            TSecurityStateResponsePckg responsePckg( response );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EGetGlobalStartupMode:

            {

            TGlobalStartupModeResponse response;

            iModel->GetStartupModeResponse( response );

            TGlobalStartupModeResponsePckg responsePckg( response );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EGetSIMLanguages:

            {

            RLanguageListResponse response;

            CleanupClosePushL( response );

            iModel->GetLanguageListResponse( response );

            TLanguageListResponsePckg responsePckg( response );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            CleanupStack::PopAndDestroy();

            break;

            }

        case EActivateRfForEmergencyCall:

            {

            TResponsePckg responsePckg( iModel->GetActivateRfResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EDeactivateRfAfterEmergencyCall:

            {

            TResponsePckg responsePckg( iModel->GetDeactivateRfResponse() );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        case EGetHiddenReset:

            {

            TBooleanResponse response;

            iModel->GetHiddenResetResponse( response );

            TBooleanResponsePckg responsePckg( response );

            iObserver->ResponseL(

                static_cast<TCommand>( aCommandId ),

                responsePckg );

            break;

            }

        default:

            RDEBUG_1( _L( "CStartupAdaptationStub: Unexpected command: %d." ), aCommandId );

            User::Panic( _L( "Unexpected command" ), KErrNotSupported );

            break;

        };

    RDEBUG( _L( "CStartupAdaptationStub::CommandProcessedL finished." ) );

    }

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

// CStartupAdaptationStub::SendEvent

//

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

//

void CStartupAdaptationStub::SendEvent( const TInt aEvent, const TInt aArg )

    {

    RDEBUG_2( _L( "CStartupAdaptationStub: SendEvent 0x%08x, 0x%08x." ), aEvent, aArg );

    TInt errorCode = KErrNone;

    TEvent eventID = static_cast<TEvent>( aEvent );

    if ( eventID == EFatalError )

        {

        TFatalErrorTypePckg params( static_cast<TFatalErrorType>( aArg ) );

        TRAP( errorCode, iObserver->EventL( eventID, params ) );

        }

    else if ( eventID == ESimEvent )

        {

        TSimEventTypePckg params( static_cast<TSimEventType>( aArg ) );

        TRAP( errorCode, iObserver->EventL( eventID, params ) );

        }

    else

        {

        TBuf8<1> dummy;

        TRAP( errorCode, iObserver->EventL( eventID, dummy ) );

        }

    if ( errorCode != KErrNone )

        {

        RDEBUG_1( _L( "CStartupAdaptationStub: EventL leave code %d." ), errorCode );

        }

    }

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

// CStartupAdaptationStub::CStartupAdaptationStub

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

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

//

CStartupAdaptationStub::CStartupAdaptationStub(

    MStartupAdaptationObserver* anObserver )

  : iObserver( anObserver ),

    iEventListener( NULL )

    {

    RDEBUG( _L( "CStartupAdaptationStub::CStartupAdaptationStub." ) );

    __ASSERT_ALWAYS( anObserver, User::Invariant() );

    RDEBUG( _L( "CStartupAdaptationStub::CStartupAdaptationStub finished." ) );

    }

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

// CStartupAdaptationStub::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CStartupAdaptationStub::ConstructL()

    {

    RDEBUG( _L( "CStartupAdaptationStub::ConstructL." ) );

    iEngine = CCommandProcessingEngine::NewL( *this );

    iModel = CStartupAdaptationStubModel::NewL();

#ifdef __STARTER_MODULE_TEST_SUPPORT__

    iEventListener = CSAStubEventListener::NewL( *this );

#endif // __STARTER_MODULE_TEST_SUPPORT__

    RDEBUG( _L( "CStartupAdaptationStub::ConstructL finished." ) );

    }

//  End of File