/*

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

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <ecom/ecom.h>

#include "usbuinotifapitest.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

#ifdef __WINS__

_LIT( KUsbAppProcPattern, "usb[*" );

#else

_LIT( KUsbAppProcPattern, "#USBSettingsApp*" );

#endif

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CUSBUiNotifApiTest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void CUSBUiNotifApiTest::Delete() 

    {

    iNotifier -> Close();

    delete iNotifier;

    iNotifier = NULL;

    }

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

// CUSBUiNotifApiTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CUSBUiNotifApiTest::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const 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( "CableConnectedNotifierTest", CUSBUiNotifApiTest::CableConnectedNotifierTest ),

        ENTRY( "FinishCableConnectedQuery", CUSBUiNotifApiTest::FinishCableConnectedQuery ),        

        ENTRY( "UsbQueriesNotifierTest", CUSBUiNotifApiTest::UsbQueriesNotifierTest ),

        ENTRY( "FinishQuery", CUSBUiNotifApiTest::FinishQuery ),

        ENTRY( "UsbOTGErrorNotifierTests", CUSBUiNotifApiTest::UsbOTGErrorNotifierTests ), 

        ENTRY( "UsbOTGWarningNotifierTests", CUSBUiNotifApiTest::UsbOTGWarningNotifierTests ),

        ENTRY( "LoadNotifiers", CUSBUiNotifApiTest::LoadNotifiersL ),

        ENTRY( "UnLoadNotifiers", CUSBUiNotifApiTest::UnLoadNotifiers ),

        ENTRY( "UsbMSMMNotifierTests", CUSBUiNotifApiTest::UsbMSMMNotifierTests ),

        ENTRY( "CancelMsmmNotifier", CUSBUiNotifApiTest::CancelMsmmNotifier ),

        ENTRY( "CancelQueryNotifier", CUSBUiNotifApiTest::CancelQueryNotifier ),

        ENTRY( "CancelOtgErrorNotifier", CUSBUiNotifApiTest::CancelOtgErrorNotifier ),

        ENTRY( "CancelOtgWarningNotifier", CUSBUiNotifApiTest::CancelOtgWarningNotifier ),

        ENTRY( "CancelCableConnectedNotifier", CUSBUiNotifApiTest::CancelCableConnectedNotifier ),

        ENTRY( "WaitForRequest", CUSBUiNotifApiTest::WaitForRequest ),

        ENTRY( "SynchStart", CUSBUiNotifApiTest::SynchStart ),	

        ENTRY( "Update", CUSBUiNotifApiTest::Update )

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CUSBUiNotifApiTest::CableConnectedNotifierTests

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

TInt CUSBUiNotifApiTest::CableConnectedNotifierTest( CStifItemParser& /*aItem*/ )

    {

    TInt res;

    TPtrC8 dummyPckg; //no parameters used

    res = iNotifier -> Connect();

    if ( res != KErrNone )

        {

        iLog -> Log( _L("Failed to connect RNotifier with value: %d"), res );

        return res;

        }   

    iLog -> Log( _L("RNotifier connected") );

    //kill the possibly running usb application

    FindAndKillProcess(KUsbAppProcPattern);

    iNotifier -> StartNotifierAndGetResponse( iReqStatus, KCableConnectedNotifierUid, 

            dummyPckg, iConnectionNotifierResponseParamsPckg );    

    return KErrNone;

    }

TInt CUSBUiNotifApiTest::FinishCableConnectedQuery( CStifItemParser& aItem )

    {

    //give time for application to start, in microseconds

    const TInt KAppLaunchDelay = 5000000; 

    TInt res;

    TPtrC optionName( KNullDesC );

    TTestOption option;

    TPtrC expectedUsbPersonalityName( KNullDesC );

    TInt expectedErrorCode;

    iLog -> Log( _L("FinishCableConnectedQuery") );

    res = aItem.GetString( _L( "FinishCableConnectedQuery" ), optionName );

    if ( res != KErrNone )

        {

        iLog -> Log( _L("GetString failed with value: %d"), res );

        iNotifier -> Close();

        return res;

        }

    iLog -> Log( _L("FinishCableConnectedQuery getting option") );

    res = GetTestOption( optionName, option );

    if ( res != KErrNone )

        {

        iLog -> Log( _L("GetTestOption failed with value: %d"), res );

        iUsbWatcher -> Close();

        iNotifier -> Close();

        return res;

        }

    iLog -> Log( _L("FinishCableConnectedQuery wait for request") );

    User::WaitForRequest( iReqStatus );

    expectedErrorCode = iReqStatus.Int();

    iLog -> Log( _L("FinishCableConnectedQuery request complete") );

    iNotifier -> Close();  

    iLog -> Log( _L("FinishCableConnectedQuery close") );

    TInt ret = KErrNone;

    switch( option )

        {

        case EQueryAccepted:

            iLog -> Log( _L("EQueryAccepted"));

            User::After(KAppLaunchDelay); //let the app start and let the tester person to see that

            ret = FindAndKillProcess(KUsbAppProcPattern);

            if (ret != KErrNone)

                {

                iLog -> Log( _L("Process start failed: %d"), ret );

                return ret;

                }

            iLog -> Log( _L("Request status value: %d, expected: %d"), expectedErrorCode, KErrCancel );

            //the notifier returns KErrCancel when clicked

            STIF_ASSERT_EQUALS( KErrCancel, expectedErrorCode );

            break;

        case EQueryCanceled:

            iLog -> Log( _L("FinishCableConnectedQuery canceled") );

            iLog -> Log( _L("Request status value: %d, expected: %d"), expectedErrorCode, KErrCancel );

            STIF_ASSERT_EQUALS( KErrCancel, expectedErrorCode );

            break;

        default:

            iLog -> Log( _L("FinishCableConnectedQuery default - not found") );

            return KErrNotFound;

        }

    iLog -> Log( _L("Test case passed!") );

    return KErrNone;

    }

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

// CBtNotifApiTest::UsbQueriesNotifierTests

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

TInt CUSBUiNotifApiTest::UsbQueriesNotifierTest( CStifItemParser& aItem )

    {

    TInt res;    

    TPtrC usbQueryName( KNullDesC );

    TUSBUIQueries usbQueryType;

    res = aItem.GetString( _L( "UsbQueriesNotifierTest" ), usbQueryName );   

    if ( res != KErrNone )

        {

        iLog -> Log( _L("GetString failed with value: %d"), res );

        iNotifier -> Close();

        return res;

        }

    res = GetQueryType( usbQueryName, usbQueryType );

    if ( res != KErrNone )

        {

        iLog -> Log( _L("GetQueryType failed with value: %d"), res );

        return res;

        }

    TUSBQueriesNotiferParams notifierParams;

    notifierParams.iDrive = 'c';

    notifierParams.iQuery = usbQueryType;

    TUSBQueriesNotifierParamsPckg notifierParamsPckg( notifierParams );

    TPckgBuf<TBool> output;

    if (!iNotifierConnected)

        {

        res = iNotifier -> Connect();

        iNotifierConnected = ETrue;

        }

    if ( res != KErrNone )

        {

        iLog -> Log( _L("Failed to connect RNotifier with value: %d"), res );

        return res;

        }   

    iLog -> Log( _L("RNotifier connected") );

    switch( usbQueryType )

        {

        case EUSBNoMemoryCard:

            iCompleteQuery = ETrue;

            break;

        case EUSBStorageMediaFailure:

        case EUSBChangeFromMassStorage:

            iCompleteQuery = EFalse;

            break;

        default:

            break; 

        }

    iNotifier -> StartNotifierAndGetResponse( iReqStatus, KQueriesNotifier, 

            notifierParamsPckg, output ); 

    iLog -> Log( _L("StartNotifierAndGetResponse ready") );

    return KErrNone;

    }

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

// CBtNotifApiTest::UsbOTGErrorNotifierTests

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

TInt CUSBUiNotifApiTest::UsbOTGErrorNotifierTests( CStifItemParser& aItem )

    {

    TInt res;    

    TPtrC usbQueryName( KNullDesC );

    TUsbUiNotifOtgError usbOTGErrorType;

    res = aItem.GetString( _L( "UsbOTGErrorNotifierTests" ), usbQueryName );   

    if ( res != KErrNone )

        {

        iLog -> Log( _L("GetString failed with value: %d"), res );

        iNotifier -> Close();

        return res;

        }

    res = GetOTGErrorType( usbQueryName, usbOTGErrorType );

    if ( res != KErrNone )

        {

        iLog -> Log( _L("usbOTGErrorType failed with value: %d"), res );

        return res;

        }    

    if (!iNotifierConnected)

        {

        res = iNotifier -> Connect();

        iNotifierConnected = ETrue;

        }

    if ( res != KErrNone )

        {

        iLog -> Log( _L("Failed to connect RNotifier with value: %d"), res );

        return res;

        }   

    iLog -> Log( _L("RNotifier connected") );

    TPckgBuf<TInt> notifierParamsPckg;

    notifierParamsPckg() = usbOTGErrorType;

    iCompleteQuery = EFalse;

    iNotifier -> StartNotifierAndGetResponse( iReqStatus, 

            KUsbUiNotifOtgError, notifierParamsPckg, iRes ); 

    return KErrNone;

    }

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

// CBtNotifApiTest::UsbOTGErrorNotifierTests

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

TInt CUSBUiNotifApiTest::UsbOTGWarningNotifierTests( CStifItemParser& aItem )

    {        

    TInt res;    

    TPtrC usbQueryName( KNullDesC );

    TUsbUiNotifOtgWarning usbOTGWarningType;

    res = aItem.GetString( _L( "UsbOTGWarningNotifierTests" ), usbQueryName );   

    if ( res != KErrNone )

        {

        iLog -> Log( _L("GetString failed with value: %d"), res );

        iNotifier -> Close();

        return res;

        }

    res = GetOTGWarningType( usbQueryName, usbOTGWarningType );

    if ( res != KErrNone )

        {

        iLog -> Log( _L("usbOTGErrorType failed with value: %d"), res );

        return res;

        }    

    if (!iNotifierConnected)

        {

        res = iNotifier -> Connect();

        iNotifierConnected = ETrue;

        }

    if ( res != KErrNone )

        {

        iLog -> Log( _L("Failed to connect RNotifier with value: %d"), res );

        return res;

        }   

    iLog -> Log( _L("RNotifier connected") );

    TPckgBuf<TInt> notifierParamsPckg;

    notifierParamsPckg() = usbOTGWarningType;

    iCompleteQuery = EFalse;

    iNotifier -> StartNotifierAndGetResponse( iReqStatus, 

            KUsbUiNotifOtgWarning, notifierParamsPckg, iRes ); 

    return KErrNone;    

    }

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

// CBtNotifApiTest::UsbMSMMNotifierTests

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

TInt CUSBUiNotifApiTest::UsbMSMMNotifierTests( CStifItemParser& aItem )

    {        

    TInt res;    

    TPtrC usbQueryName( KNullDesC );

    THostMsErrCode usbMSMMNErrorType;

    iLog -> Log( _L("------msmm------") );

    res = aItem.GetString( _L( "UsbMSMMNotifierTests" ), usbQueryName );   

    if ( res != KErrNone )

        {

        iLog -> Log( _L("GetString failed with value: %d"), res );

        iNotifier -> Close();

        return res;

        }

    res = GetMSMMrrorType( usbQueryName, usbMSMMNErrorType );

    if ( res != KErrNone )

        {

        iLog -> Log( _L("MSMMrrorType failed with value: %d"), res );

        return res;

        }    

    iErrData.iError=usbMSMMNErrorType;

    iErrPckg = iErrData;

    if (!iNotifierConnected)

        {

        res = iNotifier -> Connect();

        iNotifierConnected = ETrue;

        }

    if ( res != KErrNone )

        {

        iLog -> Log( _L("Failed to connect RNotifier with value: %d"), res );

        return res;

        }   

    iLog -> Log( _L("RNotifier connected") );

    TPckgBuf<TInt> notifierParamsPckg;

    notifierParamsPckg() = usbMSMMNErrorType;

    iCompleteQuery = EFalse;

    iNotifier -> StartNotifierAndGetResponse( iReqStatus, KUsbUiNotifMsmmError, iErrPckg, iRes ); 

    return KErrNone;    

    }

TInt CUSBUiNotifApiTest::CancelMsmmNotifier( CStifItemParser& /*aItem*/ ) 

    {

    return ( iNotifier->CancelNotifier(KUsbUiNotifMsmmError) );

    }

TInt CUSBUiNotifApiTest::CancelQueryNotifier( CStifItemParser& /*aItem*/ ) 

    {

    iLog -> Log( _L("CancelQueryNotifier") );

    return ( iNotifier->CancelNotifier(KQueriesNotifier) );

    }

TInt CUSBUiNotifApiTest::CancelOtgErrorNotifier( CStifItemParser& /*aItem*/ ) 

    {

    return ( iNotifier->CancelNotifier(KUsbUiNotifOtgError) );

    }

TInt CUSBUiNotifApiTest::CancelOtgWarningNotifier( CStifItemParser& /*aItem*/ ) 

    {

    return ( iNotifier->CancelNotifier(KUsbUiNotifOtgWarning) );

    }

TInt CUSBUiNotifApiTest::CancelCableConnectedNotifier( CStifItemParser& /*aItem*/ ) 

    {

    return ( iNotifier->CancelNotifier(KCableConnectedNotifierUid) );

    }

TInt CUSBUiNotifApiTest::WaitForRequest( CStifItemParser& /*aItem*/ ) 

    {

    User::WaitForRequest( iReqStatus );

    return KErrNone;

    }

TInt CUSBUiNotifApiTest::SynchStart(CStifItemParser& aItem )

{

    TInt res;    

    TPtrC usbQueryName( KNullDesC );

    TUsbUiNotifOtgWarning usbOTGWarningType;

    res = aItem.GetString( _L( "SynchStart" ), usbQueryName );   

    if ( res != KErrNone )

        {

        iLog -> Log( _L("GetString failed with value: %d"), res );

        iNotifier -> Close();

        return res;

        }

    res = GetOTGWarningType( usbQueryName, usbOTGWarningType );

    if ( res != KErrNone )

        {

        iLog -> Log( _L("usbOTGErrorType failed with value: %d"), res );

        return res;

        }    

    res = iNotifier -> Connect();

    if ( res != KErrNone )

        {

        iLog -> Log( _L("Failed to connect RNotifier with value: %d"), res );

        return res;

        }   

    iLog -> Log( _L("RNotifier connected") );

    TPckgBuf<TInt> notifierParamsPckg;

    notifierParamsPckg() = usbOTGWarningType;

    iCompleteQuery = EFalse;

    TInt retVal = iNotifier -> StartNotifier( KUsbUiNotifOtgWarning, notifierParamsPckg );

    iLog -> Log( _L("StartNotifier returned with value: %d"), retVal );

    iNotifier->Close();

    return retVal;    

}

TInt CUSBUiNotifApiTest::Update(CStifItemParser& /*aItem*/ )

{

    //delay in microseconds before updating the notifier

    const TInt KUpdateDelay = 2000000;

    TInt res;    

    TPtrC usbQueryName( KNullDesC );

    res = iNotifier -> Connect();

    if ( res != KErrNone )

        {

        iLog -> Log( _L("Failed to connect RNotifier with value: %d"), res );

        return res;

        }