diff -r 000000000000 -r a2952bb97e68 mmappcomponents/mmmtpdataprovider/tsrc/mtpdataprovidertestmodule/src/ctestobserver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmappcomponents/mmmtpdataprovider/tsrc/mtpdataprovidertestmodule/src/ctestobserver.cpp	Thu Dec 17 08:55:47 2009 +0200
@@ -0,0 +1,754 @@
+/*
+* 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 observer to act as dummy mtp framework
+*
+*/
+
+
+#include "ctestobserver.h"
+#include "cmmmtpdataprovidertestmodule.h"
+#include "cmmmtpdataprovidertester.h"
+#include <mtp/tmtptypeevent.h>
+#include <mtp/tmtptyperesponse.h>
+#include <mtp/mtpprotocolconstants.h>
+#include <mtp/mmtpdataprovider.h>
+#include <mtp/cmtptypeobjectinfo.h>
+#include <mtp/cmtptypestring.h>
+#include <mtp/cmtptypeobjectproplist.h>
+#include <mtp/cmtptypefile.h>
+#include <barsc.h>
+#include <barsread.h>
+#include <stiflogger.h>
+#include <settingserverclient.h>
+#include <mpxmedia.h>
+#include "logging.h"
+
+#ifdef LOGGER
+#undef LOGGER
+#endif
+#define LOGGER iLog
+
+_LIT( KResFileName, "Z:\\resource\\mmmtpdataprovidertester.rsc" );
+
+const TInt KDataProviderId = 1;
+
+CTestObserver::CTestObserver( CMmMtpDataProviderTestModule* aTestModule )
+        : iObjectEnumerationComplete( EFalse ),
+          iStorageEnumerationComplete( EFalse ),
+          iTestModule( aTestModule ) 
+    {
+    // no implementation required
+    }
+
+CTestObserver::~CTestObserver()
+    {
+    PRINTF0( ">CTestObserver::~CTestObserver" );
+    iFsSession.Close();
+    delete iStorageManager;
+    delete iTestObjManager;
+    delete iActiveSchedulerWait;
+    PRINTF0( "<CTestObserver::~CTestObserver" );
+    delete iLog;
+    }
+
+CTestObserver* CTestObserver::NewLC( CMmMtpDataProviderTestModule* aTestModule ) 
+    { 
+    CTestObserver* self = new ( ELeave ) CTestObserver( aTestModule );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    return self;
+    }
+
+CTestObserver* CTestObserver::NewL( CMmMtpDataProviderTestModule* aTestModule ) 
+    { 
+    CTestObserver* self = CTestObserver::NewLC( aTestModule );
+    CleanupStack::Pop();
+    return self;
+    }
+
+void CTestObserver::ConstructL() 
+    {
+    TFileName logFileName;  
+    logFileName.Copy( KMtpDataProviderTestModuleLogFile );
+    
+    iLog = CStifLogger::NewL( KMtpDataProviderTestModuleLogPath, 
+            logFileName,
+            CStifLogger::ETxt,
+            TRACE_TARGET,
+            ETrue, ETrue, ETrue, EFalse, ETrue );
+    
+    PRINTF0( ">CTestObserver::ConstructL" );
+    iStorageManager = CTestStorageMgr::NewL();
+    iTestObjManager = CTestObjectManager::NewL();
+    iFsSession.Connect();
+    iActiveSchedulerWait = new ( ELeave ) CActiveSchedulerWait();
+    
+    RResourceFile resFile;
+    CleanupClosePushL( resFile );
+    
+    resFile.OpenL( Fs(), KResFileName );
+    const TInt KDefaultResourceId( 1 );
+    HBufC8* resBuffer( resFile.AllocReadLC( KDefaultResourceId ) );
+    TResourceReader resReader;
+    resReader.SetBuffer( resBuffer );
+    
+    // WORD type
+    TInt temp;
+    HBufC* tempBuf;
+    temp = resReader.ReadUint16(); // read and discard type
+    temp = resReader.ReadInt8(); // read and discard version
+    temp = resReader.ReadInt8(); // read and discard enumeration persistent flag
+    temp = resReader.ReadUint16(); // read and discard supported modes 
+
+    tempBuf = resReader.ReadHBufCL(); // read server name
+    delete tempBuf;
+    tempBuf = resReader.ReadHBufCL(); // read server image name
+    delete tempBuf;
+
+    // LLINK opaque_resource
+    iResourceId = resReader.ReadUint32();
+    __TRACE( KPrint, ( _L( "Resource id = 0x%x" ), iResourceId ) );
+    temp = resReader.ReadUint8(); // read and discard enumeration phase
+    temp = temp; // prevent warning
+    CleanupStack::PopAndDestroy( resBuffer );
+    CleanupStack::PopAndDestroy( &resFile );
+    
+    PRINTF0( "<CTestObserver::ConstructL" );
+    }
+
+TUint CTestObserver::DataProviderId() const
+    {
+    TUint id = KDataProviderId;
+    PRINTF1( "<>CTestObserver::DataProviderId id = %d", id );
+    return id;
+    }
+
+TMTPOperationalMode CTestObserver::Mode() const
+    {
+    TMTPOperationalMode mode = EModeMTP;
+    PRINTF1( "<>CTestObserver::Mode mode = %d", mode );
+    return EModeMTP;
+    }
+
+void CTestObserver::ReceiveDataL( MMTPType& aData,
+        const TMTPTypeRequest& aRequest, MMTPConnection& /*aConnection*/ )
+    {
+    TInt requestCode = aRequest.Uint16( TMTPTypeRequest::ERequestOperationCode );
+    TInt sessionId = aRequest.Uint32( TMTPTypeRequest::ERequestSessionID );
+    
+    PRINTF2( ">CTestObserver::ReceiveDataL request = 0x%x session = %d", requestCode, sessionId );
+    
+    SetPhaseL( EDataIToRPhase );
+    
+    TUint type = aData.Type();
+    PRINTV1( "Type of data: 0x%x", type );
+    if ( type == EMTPTypeUndefined )
+        {
+        PRINTN0( "Null data received, executing dummy data phase" );
+        return;
+        }
+    
+    switch ( requestCode ) 
+        {
+        case EMTPOpCodeSendObjectInfo:
+            {
+            PRINTN0( "Receiving data for SendObjectInfo" );
+            if ( type != EMTPTypeObjectInfoDataset )
+                {
+                PRINTE2( "Wrong data type received: 0x%x != 0x%x", type, EMTPTypeObjectInfoDataset );
+                User::Leave( KErrArgument );
+                }
+            iTestModule->iPluginTester->SendObjectInfoReceiveData(
+                    static_cast <CMTPTypeObjectInfo*>( &aData ) );
+            }
+            break;
+        case EMTPOpCodeSendObject:
+            {
+            PRINTN0( "Receiving data for SendObject" );
+            if ( type != EMTPTypeFile )
+                {
+                PRINTE2( "Wrong data type received: 0x%x != 0x%x", type,
+                        EMTPTypeFile );
+                User::Leave( KErrArgument );
+                }
+            iTestModule->iPluginTester->SendObjectReceiveDataL(
+                    static_cast<CMTPTypeFile*>( &aData ) );
+            }
+            break;
+        case EMTPOpCodeSetObjectPropList:
+            {
+            PRINTN0( "Receiving data for SetObjectPropList" );
+            if ( type != EMTPTypeObjectPropListDataset )
+                {
+                PRINTE2( "Wrong data type received: 0x%x != 0x%x", type, EMTPTypeObjectPropListDataset );
+                User::Leave( KErrArgument );
+                }
+            iTestModule->iPluginTester->SetObjectPropListReceiveDataL(
+                    static_cast <CMTPTypeObjectPropList* >( &aData ) );
+            }
+            break;
+        case EMTPOpCodeSetObjectPropValue:
+            {
+            PRINTN0( "Receiving data for SetObjectPropValue" );
+            iTestModule->iPluginTester->SetObjectPropValueReceiveDataL(
+                    aRequest, &aData );
+            }
+            break;
+        }
+    PRINTF0( "<CTestObserver::ReceiveDataL" );
+    }
+
+void CTestObserver::SendDataL(const MMTPType& aData, 
+        const TMTPTypeRequest& aRequest, MMTPConnection& /*aConnection*/)
+    {
+    TUint16 operationCode = aRequest.Uint16( TMTPTypeRequest::ERequestOperationCode );
+    PRINTF1( ">CTestObserver::SendDataL operation = 0x%x", operationCode );
+    SetPhaseL( EDataRToIPhase );
+    iMMTPTypeData = &aData;
+    switch ( operationCode ) 
+        {
+        case EMTPOpCodeGetObjectPropList:
+            if ( iPendingOperation == EGetObjectPropList )
+                {
+                PRINTN0( "GetObjectPropList async operation finished successfully" );
+                iAsyncResult = KErrNone;
+                }
+            else
+                {
+                PRINTE0( "GetObjectPropList async operation finished in incorrect state" );
+                iAsyncResult = KErrNotReady;
+                }
+            if ( iActiveSchedulerWait->IsStarted() )
+                {
+                iActiveSchedulerWait->AsyncStop();
+                }
+            iPendingOperation = EIdleOperation;
+            break;
+        }
+    PRINTF0( "<CTestObserver::SendDataL" );
+    }
+
+void CTestObserver::SendEventL(
+        const TMTPTypeEvent& aEvent, MMTPConnection& /*aConnection*/ )
+    {
+    TUint16 eventCode = aEvent.Uint16( TMTPTypeEvent::EEventCode );
+    TUint32 sessionId = aEvent.Uint32( TMTPTypeEvent::EEventSessionID );
+    PRINTF2( "<>CTestObserver::SendEventL event = 0x%x session = %d", eventCode, sessionId );
+    PRINTE0( "NOT IMPLEMENTED" );
+    }
+
+void CTestObserver::SendEventL( const TMTPTypeEvent& aEvent )
+    {
+    TUint16 eventCode = aEvent.Uint16( TMTPTypeEvent::EEventCode );
+    TUint32 sessionId = aEvent.Uint32( TMTPTypeEvent::EEventSessionID );
+    PRINTF2( "<>CTestObserver::SendEventL event = 0x%x session = %d", eventCode, sessionId );
+    PRINTE0( "NOT IMPLEMENTED" );
+    }
+
+void CTestObserver::SendResponseL(
+        const TMTPTypeResponse& aResponse,
+        const TMTPTypeRequest& aRequest,
+        MMTPConnection& /*aConnection*/ )
+    {
+    TUint16 response = aResponse.Uint16( TMTPTypeResponse::EResponseCode );
+    TUint16 operationCode = aRequest.Uint16( TMTPTypeRequest::ERequestOperationCode );
+    PRINTF2( ">CTestObserver::SendResponseL response = 0x%x operation = 0x%x", response, operationCode );
+    TInt result = KErrNone;
+    if ( iPhase == ECompletingPhase )
+        {
+        PRINTN1( "Response 0x%x received while already in completing phase", response );
+        }
+    else
+        {
+        SetPhaseL( ECompletingPhase );
+        TMTPTypeResponse::CopyL( aResponse, iResponse );
+        iResponseCode = response;
+        switch ( operationCode ) 
+            {
+            case EMTPOpCodeGetObjectPropList:
+                if ( iPendingOperation == EGetObjectPropList )
+                    {
+                    PRINTN0( "GetObjectPropList async operation aborted" );
+                    iAsyncResult = KErrAbort;
+                    if ( iActiveSchedulerWait->IsStarted() )
+                        {
+                        iActiveSchedulerWait->AsyncStop();
+                        }
+                    iPendingOperation = EIdleOperation;
+                    }
+                break;
+            case EMTPOpCodeSetObjectPropList:
+                if ( iPendingOperation == ESetObjectPropList )
+                    {
+                    PRINTN0( "SetObjectPropList async operation finished successfully" );
+                    iAsyncResult = KErrNone;
+                    }
+                else
+                    {
+                    PRINTE0( "SetObjectPropList async operation finished in incorrect state" );
+                    iAsyncResult = KErrNotReady;
+                    }
+                if ( iActiveSchedulerWait->IsStarted() )
+                    {
+                    iActiveSchedulerWait->AsyncStop();
+                    }
+                iPendingOperation = EIdleOperation;
+                break;
+            case EMTPOpCodeDeleteObject:
+                if ( iPendingOperation == EDeleteObject )
+                    {
+                    PRINTN0( "DeleteObject async operation finished successfully" );
+                    iAsyncResult = KErrNone;
+                    }
+                else
+                    {
+                    PRINTE0( "DeleteObject async operation finished in incorrect state" );
+                    iAsyncResult = KErrNotReady;
+                    }
+                if ( iActiveSchedulerWait->IsStarted() )
+                    {
+                    iActiveSchedulerWait->AsyncStop();
+                    }
+                iPendingOperation = EIdleOperation;
+                break;
+            }
+        }
+    PRINTF0( "<CTestObserver::SendResponseL" );
+    }
+
+void CTestObserver::TransactionCompleteL(const TMTPTypeRequest& /*aRequest*/,
+        MMTPConnection& /*aConnection*/)
+    {
+    PRINTF0( "<>CTestObserver::TransactionCompleteL" );
+    SetPhaseL( EIdlePhase );
+    }
+
+void CTestObserver::RouteRequestRegisterL(const TMTPTypeRequest& /*aRequest*/,
+        MMTPConnection& /*aConnection*/)
+    {
+    PRINTF0( "<>CTestObserver::RouteRequestRegisterL" );
+    }
+
+void CTestObserver::RouteRequestUnregisterL(const TMTPTypeRequest& /*aRequest*/,
+        MMTPConnection& /*aConnection*/)
+    {
+    PRINTF0( "<>CTestObserver::RouteRequestUnregisterL" );
+    }
+
+void CTestObserver::ObjectEnumerationCompleteL( TUint32 aStorageId )
+    {
+    PRINTF1( ">CTestObserver::ObjectEnumerationCompleteL aStorageId = 0x%x", aStorageId );
+    
+    if ( iPendingOperation == EObjectEnumeration )
+        {
+        if ( iActiveSchedulerWait->IsStarted() )
+            {
+            iActiveSchedulerWait->AsyncStop();
+            }
+        iAsyncResult = KErrNone;
+        iObjectEnumerationComplete = ETrue;
+        iPendingOperation = EIdleOperation;
+        }
+    else
+        {
+        PRINTE0( "Unexpected pending operation" );
+        iObjectEnumerationComplete = EFalse;
+        iAsyncResult = KErrNotReady;
+        }
+    PRINTF0( "<CTestObserver::ObjectEnumerationCompleteL" );
+    }
+
+void CTestObserver::StorageEnumerationCompleteL()
+    {
+    PRINTF0( ">CTestObserver::StorageEnumerationCompleteL" );
+    if ( iPendingOperation == EStorageEnumeration )
+        {
+        if ( iActiveSchedulerWait->IsStarted() )
+            {
+            iActiveSchedulerWait->AsyncStop();
+            }
+        iAsyncResult = KErrNone;
+        iStorageEnumerationComplete = ETrue;
+        iPendingOperation = EIdleOperation;
+        }
+    else
+        {
+        PRINTE0( "Unexpected pending operation" );
+        iStorageEnumerationComplete = EFalse;
+        iAsyncResult = KErrNotReady;
+        }
+    PRINTF0( "<CTestObserver::StorageEnumerationCompleteL" );
+    }
+
+TBool CTestObserver::ObjectEnumerationComplete() const
+    {
+    PRINTF1( "<>CTestObserver::ObjectEnumerationComplete = %d", iObjectEnumerationComplete );
+    return iObjectEnumerationComplete;
+    }
+
+TInt CTestObserver::ObjectEnumerationError() const
+    {
+    PRINTF1( "<>CTestObserver::ObjectEnumerationError = %d", iObjectEnumerationError );
+    return iObjectEnumerationError;
+    }
+
+TBool CTestObserver::StorageEnumerationComplete() const
+    {
+    PRINTF1( "<>CTestObserver::ObjectEnumerationError = %d", iStorageEnumerationComplete );
+    return iStorageEnumerationComplete;
+    }
+
+// sets the phase member variable and leaves if state transition is illegal
+TMTPTransactionPhase CTestObserver::SetPhaseL( TMTPTransactionPhase aPhase )
+    {
+    PRINTF1( ">CTestObserver::SetPhaseL aPhase = 0x%x", aPhase )
+    TMTPTransactionPhase result = iPhase;
+    switch ( aPhase )
+        {
+        case EUndefined:
+            iPhase = aPhase;
+            result = iPhase;
+            break;
+        case EIdlePhase:
+            if ( iPhase == ECompletingPhase )
+                {
+                iPhase = aPhase;
+                result = iPhase;
+                }
+            else
+                {
+                PRINTE0( "Illegal attempt to switch to idle phase" );
+                PRINTE1( "Current phase: 0x%x", iPhase );
+                User::Leave( KErrNotReady );
+                }
+            break;
+        case ERequestPhase:
+            if ( iPhase == EUndefined )
+                {
+                iPhase = aPhase;
+                result = iPhase;
+                }
+            else
+                {
+                PRINTE0( "Illegal attempt to switch to request phase" );
+                PRINTE1( "Current phase: 0x%x", iPhase );
+                User::Leave( KErrNotReady );
+                }
+            break;
+        case EResponsePhase:
+            switch ( iPhase )
+                {
+                case ECompletingPhase:
+                    PRINTN0( "Attempted to switch back to response phase from completing phase" );
+                    // while already in completing phase, must not change internal state
+                    result = aPhase;
+                    break;
+                case ERequestPhase:
+                case EDataIToRPhase:
+                case EDataRToIPhase:
+                    iPhase = aPhase;
+                    result = iPhase;
+                    break;
+                default:
+                    PRINTE0( "Illegal attempt to switch to response phase" );
+                    PRINTE1( "Current phase: 0x%x", iPhase );
+                    User::Leave( KErrNotReady );
+                    break;
+                }
+            break;
+        case ECompletingPhase:
+            switch ( iPhase )
+                {
+                case ECompletingPhase:
+                    // allow switch but print notice
+                    PRINTN0( "Attempted to switch to completing phase while already in completing phase" );
+                    result = iPhase;
+                    break;
+                case EIdlePhase:
+                    // some operations do automatically the completing phase
+                    // allow switch but don't change internal phase
+                    PRINTN0( "Attempted to switch to completing phase while already in idle phase" );
+                    result = aPhase;
+                    break;
+                case ERequestPhase:
+                case EDataIToRPhase:
+                case EDataRToIPhase:
+                case EResponsePhase:
+                    iPhase = aPhase;
+                    result = iPhase;
+                    break;
+                default:
+                    PRINTE0( "Illegal attempt to switch to completing phase" );
+                    PRINTE1( "Current phase: 0x%x", iPhase );
+                    User::Leave( KErrNotReady );
+                    break;
+                }
+            break;
+        case EDataIToRPhase:
+            if ( iPhase == ERequestPhase )
+                {
+                iPhase = aPhase;
+                result = iPhase;
+                }
+            else
+                {
+                PRINTE0( "Illegal attempt to switch to data i to r phase" );
+                PRINTE1( "Current phase: 0x%x", iPhase );
+                User::Leave( KErrNotReady );
+                }
+            break;
+        case EDataRToIPhase:
+            if ( iPhase == ERequestPhase )
+                {
+                iPhase = aPhase;
+                result = iPhase;
+                }
+            else
+                {
+                PRINTE0( "Illegal attempt to switch to data r to i phase" );
+                PRINTE1( "Current phase: 0x%x", iPhase );
+                User::Leave( KErrNotReady );
+                }
+            break;
+        default:
+            PRINTE0( "Attempting to switch to illegal phase" );
+            PRINTE1( "Tried to change to phase: 0x%x", aPhase );
+            User::Leave( KErrArgument );
+            break;
+        }
+    PRINTF1( "<CTestObserver::SetPhaseL result = %d", result );
+    return result;
+    }
+
+const MMTPDataProviderConfig& CTestObserver::DataProviderConfig() const
+    {
+    PRINTF0( "<>CTestObserver::DataProviderConfig" );
+    return *this;
+    }
+
+const MMTPFrameworkConfig& CTestObserver::FrameworkConfig() const
+    {
+    PRINTF0( "<>CTestObserver::FrameworkConfig" );
+    PRINTE0( "NOT IMPLEMENTED" );
+    }
+
+ 
+MMTPObjectMgr& CTestObserver::ObjectMgr() const
+     {
+     PRINTF0( "<>CTestObserver::ObjectMgr" );
+     return *iTestObjManager;
+     }
+
+MMTPReferenceMgr& CTestObserver::ReferenceMgr() const
+    {
+    PRINTF0( "<>CTestObserver::ReferenceMgr()" );
+    PRINTE0( "NOT IMPLEMENTED" );
+    }
+
+MMTPStorageMgr& CTestObserver::StorageMgr() const
+    {
+    PRINTF0( "<>CTestObserver::StorageMgr" );
+    return *iStorageManager;
+    }
+ 
+
+RFs& CTestObserver::Fs() const
+    {
+    PRINTF0( "<>CTestObserver::Fs()" );
+    return const_cast<RFs&>(iFsSession);
+    }
+
+void CTestObserver::SetPendingOperation( TAsyncOperation aOperation )
+    {
+    PRINTF1( "<>CTestObserver::SetPendingOperation aOperation = %d", aOperation );
+    iPendingOperation = aOperation;
+    }
+
+TInt CTestObserver::WaitForPendingOperation()
+    {
+    PRINTF0( ">CTestObserver::WaitForPendingOperation" );
+    if ( iPendingOperation != EIdleOperation )
+        {
+        if ( iActiveSchedulerWait->IsStarted() )
+            {
+            PRINTE0( "Active scheduler wait already started" );
+            iAsyncResult = KErrNotReady;
+            }
+        else
+            {
+            iActiveSchedulerWait->Start();
+            }
+        }
+    else
+        {
+        PRINTN0( "Pending operation already finished" );
+        }
+    PRINTF1( "<CTestObserver::WaitForPendingOperation result = %d", iAsyncResult );
+    return iAsyncResult;
+    }
+
+TInt CTestObserver::GetPendingResult()
+    {
+    PRINTF1( "<>CTestObserver::GetPendingResult = %d", iAsyncResult );
+    return iAsyncResult;
+    }
+
+void CTestObserver::HandleAbstractMediaExportCompletedL( CMPXMedia* /*aMedia*/, TInt /*aErr*/ )
+    {
+    PRINTF0( "<>CTestObserver::GetPendingResult" );
+    PRINTE0( "NOT IMPLEMENTED" );
+    }
+
+void CTestObserver::HandleAbstractMediaImportCompletedL( CMPXMedia* aMedia, TInt aErr )
+    {
+    PRINTF0( ">CTestObserver::HandleAbstractMediaImportCompletedL" );
+    if ( iPendingOperation == EHarvesterImportAbstractMedia )
+        {
+        // TODO: add check function for the harvest results using this media object
+        if ( aMedia != NULL )
+            {
+            delete aMedia;
+            }
+        iAsyncResult = aErr;
+        }
+    else
+        {
+        PRINTE0( "HarvesterImportPlaylist async operation finished in incorrect state" );
+        iAsyncResult = KErrNotReady;
+        }
+    if ( iActiveSchedulerWait->IsStarted() )
+        {
+        iActiveSchedulerWait->AsyncStop();
+        }
+    PRINTF0( "<CTestObserver::HandleAbstractMediaImportCompletedL" );
+    }
+
+void CTestObserver::HandleFileAddCompletedL( CMPXMedia* aMedia, TInt aErr )
+    {
+    PRINTF1( ">CTestObserver::HandleFileAddCompletedL aErr = %d", aErr );
+    if ( iPendingOperation == EHarvesterAddObject )
+        {
+        // TODO: add check function for the harvest results using this media object
+        if ( aMedia != NULL )
+            {
+            delete aMedia;
+            }
+        iAsyncResult = aErr;
+        }
+    else
+        {
+        PRINTE0( "HarvesterAddObject async operation finished in incorrect state" );
+        iAsyncResult = KErrNotReady;
+        }
+    if ( iActiveSchedulerWait->IsStarted() )
+        {
+        iActiveSchedulerWait->AsyncStop();
+        }
+    PRINTF0( "<CTestObserver::HandleFileAddCompletedL" );
+    }
+
+void CTestObserver::HandleDeleteCompletedL( TInt aErr )
+    {
+    PRINTF1( ">CTestObserver::HandleDeleteCompletedL aErr = %d", aErr );
+    if ( iPendingOperation == EHarvesterDeleteObject )
+        {
+        iAsyncResult = aErr;
+        }
+    else
+        {
+        PRINTE0( "HarvesterDeleteObject async operation finished in incorrect state" );
+        iAsyncResult = KErrNotReady;
+        }
+    if ( iActiveSchedulerWait->IsStarted() )
+        {
+        iActiveSchedulerWait->AsyncStop();
+        }
+    PRINTF0( "<CTestObserver::HandleDeleteCompletedL" );
+    }
+
+void CTestObserver::HandleFileImportCompletedL( CMPXMedia* /*aMedia*/, TInt /*aErr*/  )
+    {
+    PRINTF0( "<>CTestObserver::HandleFileImportCompletedL" );
+    PRINTE0( "NOT IMPLEMENTED" );
+    }
+
+void CTestObserver::HandleFileGetMediaCompletedL( CMPXMedia* /*aMedia*/, TInt /*aErr*/ )
+    {
+    PRINTF0( "<>CTestObserver::HandleFileGetMediaCompletedL" );
+    PRINTE0( "NOT IMPLEMENTED" );
+    }
+
+TUint CTestObserver::UintValue( MMTPDataProviderConfig::TParameter aParam ) const
+    {
+    PRINTF1( ">CTestObserver::UintValue aParam = %d", aParam );
+    TUint result = 0;
+    switch ( aParam )
+        {
+        case EOpaqueResource:
+            result = iResourceId;
+            break;
+        default:
+            PRINTE1( "UintValue called with unexpected param: 0x%x", aParam );
+        }
+    PRINTF1( "<CTestObserver::UintValue result = %d", result );
+    return result;
+    }
+
+TBool CTestObserver::BoolValue( MMTPDataProviderConfig::TParameter aParam ) const
+    {
+    PRINTF1( ">CTestObserver::BoolValue aParam = %d", aParam );
+    TBool result = EFalse;
+    PRINTF1( "<CTestObserver::BoolValue result = %d", result );
+    return result;
+    }
+
+const TDesC& CTestObserver::DesCValue( MMTPDataProviderConfig::TParameter aParam ) const
+    {
+    PRINTF1( ">CTestObserver::DesCValue aParam = %d", aParam );
+    const TDesC* nullValue( &KNullDesC );
+    const TDesC* resValue( &KResFileName );
+    switch ( aParam )
+        {
+        case EResourceFileName:
+            PRINTF1( "<CTestObserver::DesCValue result = %S", resValue );
+            return *resValue;
+        default:
+            PRINTE1( "DesCValue called with unexpected param: 0x%x", aParam );
+            User::Leave( KErrArgument );
+        }
+    }
+
+const TDesC8& CTestObserver::DesC8Value( MMTPDataProviderConfig::TParameter aParam ) const
+    {
+    PRINTF1( "<>CTestObserver::DesC8Value aParam = %d", aParam );
+    return KNullDesC8;
+    }
+
+void CTestObserver::GetArrayValue( MMTPDataProviderConfig::TParameter aParam, RArray<TUint>& aArray ) const
+    {
+    PRINTF1( ">CTestObserver::GetArrayValue aParam = %d", aParam );
+    switch (aParam)
+        {
+        case ESupportedModes:
+            {
+            PRINTV0( "Appending MTP mode" );
+            aArray.Append(EModeMTP);
+            break;
+            }
+        default:
+            PRINTE1( "GetArrayValue called with unexpected param: 0x%x", aParam );
+            User::Leave( KErrArgument );
+        }
+    PRINTF0( "<CTestObserver::GetArrayValue" );
+    }