/*

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

* CSysErrCmdTest class implementation.

*

*/

#include <e32debug.h>

#include <stifparser.h>

#include <stiftestinterface.h>

#include <aknglobalnote.h>

#include <akncapserverclient.h>

#include <ssm/ssmcustomcommand.h>

#include "syserrcmdtest.h"

#include "syserrcmdfactory.h"

#include "syserrcmdtestsstub.h"

#include "trace.h"

//  INTERNAL INCLUDES

NONSHARABLE_CLASS( TWaitInfo )

    {

    public:

        CPeriodic* iPeriodic;

        CActiveSchedulerWait* iWait;

    };

/**

* Call back method when we need to stop active scheduler wait.

*/

LOCAL_C TInt WaitCallBack( TAny* aSelf )

    {

    if( aSelf )

        {

        TWaitInfo* info = static_cast<TWaitInfo*>( aSelf );

        if( info->iPeriodic )

            {

            info->iPeriodic->Cancel();

            }

        if( info->iWait )

            {

            if( info->iWait->IsStarted() )

                {

                info->iWait->AsyncStop();

                }

            }

        }

    return KErrNone;

    }

/**

* Helper method to wait current scheduler before teardown is completed.

*/

LOCAL_C void WaitL( TInt aIntervalInMicorseconds )

    {

    TWaitInfo info;

    // Construct periodic

    CPeriodic* periodic = CPeriodic::NewL( CActive::EPriorityStandard );

    CleanupStack::PushL( periodic );

    info.iPeriodic = periodic;

    // Construct active scheduler wait

    CActiveSchedulerWait* wait = new( ELeave ) CActiveSchedulerWait;

    CleanupStack::PushL( wait );

    info.iWait = wait;

    // Start timer and wait

    TCallBack cb( WaitCallBack, &info );

    periodic->Start( aIntervalInMicorseconds, aIntervalInMicorseconds, cb );

    wait->Start();

    // Cleanup

    CleanupStack::PopAndDestroy( wait );

    CleanupStack::PopAndDestroy( periodic );

    }

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

// CSysErrCmdTest::LibEntryL

// Returns: Poiter to CSysErrCmdTest class

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

EXPORT_C CSysErrCmdTest* LibEntryL( CTestModuleIf& aTestModuleIf )

    {

    FUNC_LOG;

    CSysErrCmdTest* libEntry( CSysErrCmdTest::NewL( aTestModuleIf ) );

    return libEntry;

    }

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

// CSysErrCmdTest::CSysErrCmdTest

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

CSysErrCmdTest::CSysErrCmdTest( CTestModuleIf& aTestModuleIf ) :

    CScriptBase( aTestModuleIf )

    {

    FUNC_LOG;    

    }

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

// CSysErrCmdTest::ConstructL

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

void CSysErrCmdTest::ConstructL()

    {

    FUNC_LOG;

    iExecuteHandler = CAsyncRequestHandler<CSysErrCmdTest>::NewL(

                                    *this,

                                    HandleIssueRequest,

                                    HandleRunL,

                                    HandleRunError,

                                    HandleDoCancel,

                    CAsyncRequestHandler<CSysErrCmdTest>::ERequestOneShot );

    User::LeaveIfError( iFs.Connect() );

    iCustCmdEnvStub = SysErrCmdTestsStub::CustomCommandEnvStubL( iFs );

    }

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

// CSysErrCmdTest::NewL

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

CSysErrCmdTest* CSysErrCmdTest::NewL( CTestModuleIf& aTestModuleIf )

    {

    FUNC_LOG;

    CSysErrCmdTest* self = new (ELeave) CSysErrCmdTest( aTestModuleIf );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSysErrCmdTest::~CSysErrCmdTest

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

CSysErrCmdTest::~CSysErrCmdTest()

    {

    iFs.Close();

    delete iExecuteHandler;

    delete iCustCmdEnvStub;

    FUNC_LOG;    

    }

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

// CSysErrCmdTest::RunMethodL

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

TInt CSysErrCmdTest::RunMethodL( CStifItemParser& aItem )

    {

    FUNC_LOG;

    const TStifFunctionInfo KFunctions[] =

        {

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

        ENTRY( "CreateAndDestroy", CSysErrCmdTest::CreateAndDestroyL ),

        ENTRY( "InitAndClose", CSysErrCmdTest::InitAndCloseL ),

        ENTRY( "Execute", CSysErrCmdTest::ExecuteL ),

        ENTRY( "ExecuteCancel", CSysErrCmdTest::ExecuteCancelL ),

        ENTRY( "ExecuteAfterGlobalNote", CSysErrCmdTest::ShowAfterAknGlobalNoteL ),

        ENTRY( "ExecuteAfterUiServiceGlobalNote", CSysErrCmdTest::ShowAfterUiServerGlobalNoteL )

        };

    const TInt count( sizeof( KFunctions ) / sizeof( TStifFunctionInfo ) );

    TInt ret( RunInternalL( KFunctions, count, aItem ) );

    return ret;

    }

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

// CSysErrCmdTest::CreateAndDestroyL

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

TInt CSysErrCmdTest::CreateAndDestroyL( CStifItemParser& aItem )

    {

    FUNC_LOG;

    ( void )aItem;

    MSsmCustomCommand* sysErrCmd = SysErrCmdFactory::SysErrCmdNewL();

    sysErrCmd->Release();

    return KErrNone;

    }

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

// CSysErrCmdTest::InitAndCloseL

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

TInt CSysErrCmdTest::InitAndCloseL( CStifItemParser& aItem )

    {

    FUNC_LOG;

    ( void )aItem;

    MSsmCustomCommand* sysErrCmd = SysErrCmdFactory::SysErrCmdNewL();

    TInt err( sysErrCmd->Initialize( iCustCmdEnvStub ) );

    ERROR( err, "Failed to init syserrcmd" );

    User::LeaveIfError( err );

    sysErrCmd->Close();    

    sysErrCmd->Release();

    return KErrNone;

    }

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

// CSysErrCmdTest::ExecuteL

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

TInt CSysErrCmdTest::ExecuteL( CStifItemParser& aItem )

    {

    FUNC_LOG;

    ( void )aItem;

    iSysErrCmd = SysErrCmdFactory::SysErrCmdNewL();

    TInt err( iSysErrCmd->Initialize( iCustCmdEnvStub ) );

    ERROR( err, "Failed to init syserrcmd" );

    User::LeaveIfError( err );

    iExecuteHandler->IssueRequest();

    WaitL( 5000 );

    iSysErrCmd->Close();

    iSysErrCmd->Release();

    INFO_1( "Execution result %d", iExecutionResult );

    return iExecutionResult;

    }

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

// CSysErrCmdTest::ExecuteL

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

TInt CSysErrCmdTest::ExecuteCancelL( CStifItemParser& aItem )

    {

    FUNC_LOG;

    ( void )aItem;

    iSysErrCmd = SysErrCmdFactory::SysErrCmdNewL();

    TInt err( iSysErrCmd->Initialize( iCustCmdEnvStub ) );

    ERROR( err, "Failed to init syserrcmd" );

    User::LeaveIfError( err );

    iExecuteHandler->IssueRequest();

    WaitL( 5000 );

    iSysErrCmd->ExecuteCancel();

    WaitL( 5000 );

    iSysErrCmd->Close();

    iSysErrCmd->Release();

    INFO_1( "ExecutionCancel result %d", iExecutionResult );

    return ( iExecutionResult == KErrCancel ) ? KErrNone : KErrGeneral;    

    }

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

// CSysErrCmdTest::ShowAfterAknGlobalNoteL

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

TInt CSysErrCmdTest::ShowAfterAknGlobalNoteL( CStifItemParser& aItem )

    {

    CAknGlobalNote* note = CAknGlobalNote::NewLC();

    note->ShowNoteL( EAknGlobalInformationNote, _L("CAknGlobalNote::ShowNoteL()") );

    CleanupStack::PopAndDestroy( note );

    return ExecuteL( aItem );

    }

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

// CSysErrCmdTest::ShowAfterUiServerGlobalNoteL

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

TInt CSysErrCmdTest::ShowAfterUiServerGlobalNoteL( CStifItemParser& aItem )

    {

    RAknUiServer aknSrv;

    User::LeaveIfError( aknSrv.Connect() );

    CleanupClosePushL( aknSrv );

    aknSrv.ShowGlobalNoteL(  _L("RAknUiServer::ShowGlobalNoteL()"), EAknGlobalInformationNote );

    CleanupStack::PopAndDestroy( &aknSrv );

    return ExecuteL( aItem );

    }

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

// CSysErrCmdTest::HandleIssueRequest

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

void CSysErrCmdTest::HandleIssueRequest( TRequestStatus& aRequest )

    {

    FUNC_LOG;

    iSysErrCmd->Execute( KNullDesC8, aRequest );

    }

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

// CSysErrCmdTest::HandleRunL

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

void CSysErrCmdTest::HandleRunL( TInt aStatus )

    {

    FUNC_LOG;

    INFO_1( "CSysErrCmdTest::HandleRunL %d", aStatus );

    if ( KErrNone != aStatus )

        {

        iExecutionResult = aStatus;

        }

    }

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

// CSysErrCmdTest::HandleRunError

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

TInt CSysErrCmdTest::HandleRunError( TInt aError )

    {

    FUNC_LOG;

    ERROR( aError, "CSysErrCmdTest::HandleRunError" );

    return KErrNone;

    }

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

// CSysErrCmdTest::HandleDoCancel

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

void CSysErrCmdTest::HandleDoCancel()

    {

    FUNC_LOG;

    }