/*

* 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:  Test module method implementations

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <stiflogger.h>

#include <stifparser.h>

#include <stiftestinterface.h>

#include <mtp/cmtpdataproviderplugin.h>

#include <mtp/mmtpdataprovider.h>

#include <ecom/ecom.h>

#include <mtp/tmtptypeevent.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/tmtptyperequest.h>

#include <mtp/cmtptypeobjectinfo.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/cmtptypefile.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypearray.h>

#include <mtp/cmtptypeobjectpropdesc.h>

#include <bautils.h>

#include <e32debug.h>

#include "cmmmtpdataprovidertestmodule.h"

#include "cmmmtpdataprovidertester.h"

#include "cmediamtpdataprovidertester.h"

#include "cabstractmediamtpdataprovidertester.h"

#include "logging.h"

// MACROS

#ifdef LOGGER

#undef LOGGER

#endif

#define LOGGER iLog

#ifdef PRINTTESTMODULEIF

#undef PRINTTESTMODULEIF

#endif

#define PRINTTESTMODULEIF( p ) TestModuleIf().Printf( 0, KTestModuleName, p );

#ifdef PRINTTESTMODULE

#undef PRINTTESTMODULE

#endif

#define PRINTTESTMODULE( p ) this->SetResultDescription( p );

// MEMBER FUNCTIONS

void CMmMtpDataProviderTestModule::Delete() 

    {

    PRINTF0( ">CMmMtpDataProviderTestModule::Delete()" );

    delete iDataProviderPlugin;

    delete iPluginTester;

    if ( iRequest != NULL )

        {

        PRINTN0( "Delete request" );

        delete iRequest;

        }

    REComSession::FinalClose();

    PRINTF0( "<CMmMtpDataProviderTestModule::Delete()" );

    }

TInt CMmMtpDataProviderTestModule::RunMethodL( CStifItemParser& aItem ) 

    {

    PRINTF0( ">CMmMtpDataProviderTestModule::RunMethodL" );

    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( "LoadPlugin", CMmMtpDataProviderTestModule::LoadPluginL ),

        ENTRY( "PrepareEnvironment", CMmMtpDataProviderTestModule::PrepareEnvironmentL ),

        ENTRY( "CleanEnvironment", CMmMtpDataProviderTestModule::CleanEnvironmentL ),

        ENTRY( "OpenSession", CMmMtpDataProviderTestModule::OpenSessionL ),

        ENTRY( "CloseSession", CMmMtpDataProviderTestModule::CloseSessionL ),

        ENTRY( "ObjectEnumeration", CMmMtpDataProviderTestModule::ObjectEnumerationL ),

        ENTRY( "StorageEnumeration", CMmMtpDataProviderTestModule::StorageEnumerationL ),

        ENTRY( "StartTransaction", CMmMtpDataProviderTestModule::StartTransactionL ),

        ENTRY( "CancelTransaction", CMmMtpDataProviderTestModule::CancelTransactionL ),

        ENTRY( "CompleteTransaction", CMmMtpDataProviderTestModule::CompleteTransactionL ),

        ENTRY( "GetObjectInfo", CMmMtpDataProviderTestModule::GetObjectInfoL ),

        ENTRY( "GetObject", CMmMtpDataProviderTestModule::GetObjectL ),

        ENTRY( "GetObjectPropValue", CMmMtpDataProviderTestModule::GetObjectPropValueL ),

        ENTRY( "GetObjectPropList", CMmMtpDataProviderTestModule::GetObjectPropListL ),

        ENTRY( "GetObjectPropDesc", CMmMtpDataProviderTestModule::GetObjectPropDescL ),

        ENTRY( "SendObjectInfo", CMmMtpDataProviderTestModule::SendObjectInfoL ),

        ENTRY( "SendObject", CMmMtpDataProviderTestModule::SendObjectL ),

        ENTRY( "SetObjectPropValue", CMmMtpDataProviderTestModule::SetObjectPropValueL ),

        ENTRY( "SetObjectPropList", CMmMtpDataProviderTestModule::SetObjectPropListL ),

        ENTRY( "DeleteObject", CMmMtpDataProviderTestModule::DeleteObjectL ),

        ENTRY( "CopyObject", CMmMtpDataProviderTestModule::CopyObjectL ),

        ENTRY( "MoveObject", CMmMtpDataProviderTestModule::MoveObjectL ),

        ENTRY( "RenameObject", CMmMtpDataProviderTestModule::RenameObjectL ),

        ENTRY( "GetPartialObject", CMmMtpDataProviderTestModule::GetPartialObjectL ),

        ENTRY( "SetObjectReferences", CMmMtpDataProviderTestModule::SetObjectReferencesL ),

        ENTRY( "GetObjectReferences", CMmMtpDataProviderTestModule::GetObjectReferencesL ),

        ENTRY( "GetObjectPropsSupported", CMmMtpDataProviderTestModule::GetObjectPropsSupportedL)

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    TInt result = RunInternalL( KFunctions, count, aItem );

    PRINTF1( "<CMmMtpDataProviderTestModule::RunMethodL, result = %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::LoadPluginL( CStifItemParser& aItem )

    {

    PRINTM0( "LoadPlugin" );

    TPtrC string;

    TInt result;

    result = aItem.GetNextString ( string );

    if ( result == KErrNone )

        {

        _LIT( KMediaDpString, "mediamtpdp" );

        _LIT( KAbstractMediaDpString, "abstractmediamtpdp" );

        const TInt KMediaDpUid = 0x10207C4B;

        const TInt KAbstractMediaDpUid = 0x10207C53;

        TInt uidValue = 0;

        if ( string.CompareF( KMediaDpString() ) == 0 )

            {

            PRINTM0( "Loading mediamtpdp plugin" );

            uidValue = KMediaDpUid;

            iPluginTester = CMediaMtpDataProviderTester::NewL();

            }

        else

            {

            if ( string.CompareF( KAbstractMediaDpString() ) == 0 )

                {

                PRINTM0( "Loading abstractmediamtpdp plugin" );

                uidValue = KAbstractMediaDpUid;

                iPluginTester = CAbstractMediaMtpDataProviderTester::NewL();

                }

            else

                {

                PRINTE0( "Unknown plugin" );

                User::Leave( KErrArgument );

                }

            }

        TUid pluginUid;

        pluginUid = TUid::Uid( uidValue );

        iDataProviderPlugin = CMTPDataProviderPlugin::NewL( pluginUid, iTestObserver );

        iPluginTester->RegisterObserver( iTestObserver, iTestConnChannel, iDataProviderPlugin );

        }

    else

        {

        PRINTE0( "Missing parameter: plugin name" );

        result = KErrArgument;

        }

    PRINTN1( "Exiting LoadPluginL with result %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::PrepareEnvironmentL( CStifItemParser& /*aItem*/ )

    {

    PRINTM0( "PrepareEnvironment" );

    TInt result = iPluginTester->PrepareEnvironmentL();

    if ( result != KErrNone )

        {

        PRINTE0( "Preparing environment failed" );

        }

    PRINTN1( "Exiting PrepareEnvironmentL with result %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::CleanEnvironmentL( CStifItemParser& /*aItem*/ )

    {

    PRINTM0( "CleanEnvironment" );

    TInt result = iPluginTester->CleanEnvironmentL();

    if ( result != KErrNone )

        {

        PRINTE0( "Cleaning environment failed" );

        }

    PRINTN1( "Exiting CleanEnvironmentL with result %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::OpenSessionL ( CStifItemParser& aItem )

    {

    PRINTM0( "OpenSession" );

    TInt result = KErrNone;

    if ( iSessionOpen )

        {

        PRINTE0( "OpenSession failed, session already open" );

        result = KErrNotReady;

        }

    else

        {

        iSessionId++;

        TInt sessionId;

        result = aItem.GetNextInt ( sessionId );

        if ( result == KErrNone )

            {

            PRINTN1( "Got session id parameter: %d", sessionId );

            iSessionId = sessionId;

            }

        else

            {

            PRINTN1( "GetNextInt returned %d", result );

            }

        TMTPNotificationParamsSessionChange param = { iSessionId, *iTestConnChannel } ;

        if ( iPluginTester->OpenSessionL_prepare( param ) )

            {

            iDataProviderPlugin->ProcessNotificationL( EMTPSessionOpened, &param );

            result = iPluginTester->OpenSessionL_checkresults();

            if ( result == KErrNone )

                {

                iSessionOpen = ETrue;

                }

            else

                {

                PRINTE0( "OpenSession result check failed" );

                }

            }

        else

            {

            PRINTE0( "OpenSession prepare phase failed" );

            result = KErrGeneral;

            }

        }

    PRINTN1( "Exiting OpenSession with result %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::CloseSessionL ( CStifItemParser& aItem )

    {

    PRINTM0( "CloseSession" );

    TInt result = KErrNone;

    if ( !iSessionOpen )

        {

        PRINTE0( "CloseSession failed, session not open" );

        result = KErrNotReady;

        }

    else

        {

        TMTPNotificationParamsSessionChange param = { iSessionId, *iTestConnChannel };

        if ( iPluginTester->CloseSessionL_prepare( param ) )

            {

            iDataProviderPlugin->ProcessNotificationL( EMTPSessionClosed, &param );

            result = iPluginTester->CloseSessionL_checkresults();

            if ( result == KErrNone )

                {

                iSessionId = 0;

                iSessionOpen = EFalse;

                iTransactionId = 0; // start transaction numbering from beginning

                iTransactionOpen = EFalse;

                }

            else

                {

                PRINTE0( "CloseSession result check failed" );

                }

            }

        else 

            {

            PRINTE0( "CloseSession prepare phase failed" );

            result = KErrGeneral;

            }

        }

    PRINTN1( "Exiting CloseSession with result %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::ObjectEnumerationL( CStifItemParser& /*aItem*/ )

    {

    PRINTM0( "ObjectEnumeration" );

    TInt result = KErrNotReady;

    TBool complete = iTestObserver->ObjectEnumerationComplete();

    if ( complete == EFalse )

        {

        CMTPStorageMetaData* physicalStorage( CMTPStorageMetaData::NewLC() );

        CMTPStorageMetaData* logicalStorage( CMTPStorageMetaData::NewLC() );

        if ( iPluginTester->ObjectEnumerationL_prepare( physicalStorage, logicalStorage ) ) 

            {

            TUint32 physicalStorageId;

            physicalStorageId = iTestObserver->StorageMgr().AllocatePhysicalStorageIdL( 0, *physicalStorage );

            physicalStorage->SetUint( CMTPStorageMetaData::EStorageId, physicalStorageId );

            TUint32 logicalStorageId;

            TRAP_IGNORE( logicalStorageId = iTestObserver->StorageMgr().AllocateLogicalStorageIdL( 0, physicalStorageId, *logicalStorage ) );

            logicalStorage->SetUint( CMTPStorageMetaData::EStorageId, logicalStorageId );

            iTestObserver->SetPendingOperation( CTestObserver::EObjectEnumeration );

            iDataProviderPlugin->StartObjectEnumerationL( KMTPStorageAll );

            iTestObserver->WaitForPendingOperation();

            result = iPluginTester->ObjectEnumerationL_checkresults( iTestObserver->ObjectMgr() );

            if ( result != KErrNone )

                {

                PRINTE0( "ObjectEnumeration result check failed" );

                }

            }

        else

            {

            PRINTE0 ( "ObjectEnumeration prepare phase failed" );

            result = KErrGeneral;

            }

        CleanupStack::PopAndDestroy( 2 ); // logicalStorage, physicalStorage

        }

     else

        {

        PRINTE0( "Object enumeration already run in this session" );

        result = KErrGeneral;

        }

    PRINTN1( "Exiting ObjectEnumerationL with result %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::StorageEnumerationL( CStifItemParser& /*aItem*/ )

    {

    PRINTM0( "StorageEnumeration" );

    TInt result = KErrNotReady;

    TBool complete = iTestObserver->StorageEnumerationComplete();

    if ( complete == EFalse )

         {

         if ( iPluginTester->StorageEnumerationL_prepare() )

             {

             iDataProviderPlugin->StartStorageEnumerationL();

             complete = iTestObserver->StorageEnumerationComplete();

             if (complete) 

                 {

                 result = KErrNone;

                 }

             }

         else 

             {

             PRINTE0( "StartStorageEnumeration prepare phase failed" );

             result = KErrGeneral;

             }

         }

     else 

         {

         PRINTE0( "Storage enumeration already run in this session" );

         result = KErrGeneral;

         }

     return result;

     } 

TInt CMmMtpDataProviderTestModule::StartTransactionL( CStifItemParser& aItem )

    {

    PRINTM0( "StartTransaction" );

    TInt result = KErrNone;

    if ( iSessionOpen )

        {

        if ( iTransactionOpen )

            {

            PRINTE0( "StartTransaction failed, transaction already open" );

            result = KErrGeneral;

            }

        else

            {

            if ( iRequest != NULL )

                {

                PRINTN0( "Delete previous request" );

                delete iRequest;

                iRequest = NULL;

                }

            iRequest = new TMTPTypeRequest();

            iTransactionId++;

            iTransactionOpen = ETrue;

            iTestObserver->SetPhaseL( EUndefined );

            }

        }

    else

        {

        PRINTE0( "StartTransaction failed, session not open" );

        result = KErrNotReady;

        }

    PRINTN1( "Exiting StartTransactionL with result %d", result );

    return result;

    }

// Notify that the current transaction has been cancelled.

// Affects:

// Response code of GetObject response phase

// Also default response code of other operations

// (EMTPRespCodeIncompleteTransfer)

// Outcome of SendObject/SendObjectInfo (should rollback)

TInt CMmMtpDataProviderTestModule::CancelTransactionL( CStifItemParser& /*aItem*/ )

    {

    PRINTM0( "CancelTransaction" );

    TInt result = KErrNone;

    iTransactionOpen = EFalse;

    TMTPTypeEvent eventDataSet;

    eventDataSet.SetUint16( TMTPTypeEvent::EEventCode, EMTPEventCodeCancelTransaction );

    iDataProviderPlugin->ProcessEventL( eventDataSet, *iTestConnChannel );

    PRINTN1( "Exiting CancelTransactionL with result %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::CompleteTransactionL( CStifItemParser& aItem )

    {

    PRINTM0( "CompleteTransaction" );

    TInt result = KErrNone;

    if ( iSessionOpen )

        {

        if ( !iTransactionOpen )

            {

            PRINTE0( "CompleteTransaction failed, transaction not open" );

            result = KErrNotReady;

            }

        else

            {

            iTransactionOpen = EFalse;

            TMTPTransactionPhase phase = iTestObserver->SetPhaseL( ECompletingPhase );

            iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel );

            }

        }

    else

        {

        PRINTE0( "CompleteTransaction failed, session not open" );

        result = KErrNotReady;

        }

    return result;

    }

TInt CMmMtpDataProviderTestModule::GetObjectInfoL( CStifItemParser& /*aItem*/ )

    {

    PRINTM0( "GetObjectInfo" );

    if ( !iTransactionOpen )

        {

        PRINTE0( "Running GetObjectInfo without open transaction" );

        return KErrGeneral;

        }

    TMTPTransactionPhase phase;

    TInt result = KErrNone;

    iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId );

    iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId );

    TUint32 objectHandle = 2;

    iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle );

    iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetObjectInfo );

    if ( iPluginTester->GetObjectInfoL_prepare( *iRequest ) ) 

        {

        phase = iTestObserver->SetPhaseL( ERequestPhase );

        iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel );

        phase = iTestObserver->SetPhaseL( EResponsePhase );

        iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel );

        if ( iTestObserver->iResponseCode != EMTPRespCodeOK )

            {

            PRINTE0( "GetObjectInfo request failed" );

            PRINTE1( "Response code: 0x%x" , iTestObserver->iResponseCode );

            result = KErrGeneral;

            }

        else

            {

            result = iPluginTester->GetObjectInfoL_checkresults( static_cast<const CMTPTypeObjectInfo*> ( iTestObserver->iMMTPTypeData ) );

            if ( result != KErrNone )

                {

                PRINTE0( "GetObjectInfo result check failed" );

                }

            }

        }

    else

        {

        PRINTE0( "GetObjectInfo prepare phase failed" );

        result = KErrGeneral;

        }

    PRINTN1( "Exiting GetObjectInfoL with result %d", result );

    return result;

    }

TInt CMmMtpDataProviderTestModule::GetObjectL( CStifItemParser& /*aItem*/ )

    {

    PRINTM0( "GetObject" );

    if ( !iTransactionOpen )

        {

        PRINTE0( "Running GetObject without open transaction" );

        return KErrGeneral;

        }

    TMTPTransactionPhase phase;

    TInt result = KErrNone;

    iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId );

    iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId );

    TUint32 objectHandle = 2;

    iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle );

    iRequest->SetUint32( TMTPTypeRequest::ERequestParameter2, KMTPFormatsAll );

    iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetObject );

    if ( iPluginTester->GetObjectL_prepare( *iRequest ) ) 

        {

        phase = iTestObserver->SetPhaseL( ERequestPhase );

        iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel );

        phase = iTestObserver->SetPhaseL( EResponsePhase );

        iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel );

        if ( iTestObserver->iResponseCode != EMTPRespCodeOK )

            {

            PRINTE0( "GetObjectInfo request failed" );