diff -r 735348f59235 -r 948c7f65f6d4 omxil/mmilapi/unittest/test_plugins/omxildummybaseilif/omxildummybaseilif.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/omxil/mmilapi/unittest/test_plugins/omxildummybaseilif/omxildummybaseilif.cpp	Wed Sep 01 12:38:50 2010 +0100
@@ -0,0 +1,298 @@
+// Copyright (c) 2008-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:
+//
+
+
+#include "omxildummybaseilif.h"
+#include "omxildummybaseilifbody.h"
+#include "omxilcoreutils.h" 
+#include "iltestuids.hrh"
+#include "milcomponentportif.h"
+#include "ilifuids.h"
+#include <openmax/il/khronos/v1_x/OMX_Types.h>
+
+const TUint32  KOMXALL = 0xFFFFFFFF;
+
+
+EXPORT_C COmxILDummyBaseILIF::COmxILDummyBaseILIF()
+    { 
+    }
+
+EXPORT_C COmxILDummyBaseILIF::~COmxILDummyBaseILIF()
+    {
+	if (iBody)
+		{
+		delete iBody;
+		}
+    }
+
+EXPORT_C void COmxILDummyBaseILIF::CreateComponentL(const TDesC8& aComponentName, 
+                                                    MILIfObserver& aComponentIfObserver)
+    {
+	iBody = CBody::NewL(*this, aComponentIfObserver, aComponentName);
+
+    User::LeaveIfError(iBody->SetPortsL());
+    }
+
+EXPORT_C void COmxILDummyBaseILIF::CreateComponentL(const TUid& /*aUid*/, 
+												    MILIfObserver& /*ComponentIfObserver*/)
+    {
+    // OMX Versions do not use this method of creation
+	User::Leave(KErrNotSupported);
+	}
+
+EXPORT_C void COmxILDummyBaseILIF::ReleaseComponent()
+    {
+ 	delete iBody;
+ 	iBody = NULL;
+ 	
+ 	delete this;
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::GetComponentInputPorts(RPointerArray<MILComponentPortIf>& aComponentPorts) const
+    {
+    return (iBody->GetComponentPorts(aComponentPorts, OMX_DirInput));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::GetComponentOutputPorts(RPointerArray<MILComponentPortIf>& aComponentPorts) const
+    {
+    return (iBody->GetComponentPorts(aComponentPorts, OMX_DirOutput));    
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::SetConfig(const TILStruct& /*aConfig*/, 
+                                             const MILComponentPortIf* /*aComponentPort*/)
+    {
+    // It should be implemented in the derived class
+    return KErrNotSupported;
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::GetConfig(TILStruct& /*aConfig*/, 
+                                             const MILComponentPortIf* /*aComponentPort*/) const
+    {
+    // It should be implemented in the derived class
+	return (KErrNotSupported);
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::Initialize()
+    {
+    return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StateIdle, NULL));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::Execute()
+    {
+    return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StateExecuting, NULL));
+    } 
+
+EXPORT_C TInt COmxILDummyBaseILIF::Pause()
+    {
+    return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StatePause, NULL));
+    }
+    
+EXPORT_C TInt COmxILDummyBaseILIF::Stop()
+    {
+    return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StateIdle, NULL));    
+    }
+    
+EXPORT_C TInt COmxILDummyBaseILIF::UnInitialize()
+	{
+	return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StateLoaded, NULL));	
+	}
+
+EXPORT_C TInt COmxILDummyBaseILIF::GetState(TILComponentState& aState) const
+    {
+    TInt error; 
+    OMX_STATETYPE state;
+    error = iBody->OmxGetState(&state);
+    aState = ConvertOmxState(state);
+    return error;
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::SendCommand(const TILCommand& aCommand)
+    {
+    OMX_COMMANDTYPE command = ConvertSymbianCommandType(aCommand.iCmd);
+    return (iBody->OmxSendCommand(command, aCommand.iData1, aCommand.iExtraData));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::FlushAllPorts()
+    {
+    return (iBody->OmxSendCommand(OMX_CommandFlush, KOMXALL, NULL));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::ComponentRoleEnum(TPtr8& aComponentRole, 
+                                                     TUint32 aIndex) const
+    {
+    return (iBody->OmxComponentRoleEnum(aComponentRole, aIndex));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::GetComponentVersion(TILComponentVersion& aVersion) const
+    {
+    return (iBody->OmxGetComponentVersion(aVersion.iComponentName, 
+                                          (OMX_VERSIONTYPE*)&aVersion.iComponentVersion, 
+                                          (OMX_VERSIONTYPE*)&aVersion.iSpecVersion, 
+                                          (OMX_UUIDTYPE*)&aVersion.iComponentUniqueID));    
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::SetComponentIfRole(const TUid& aComponentRole)
+    {
+    return (iBody->SetIfToRole(aComponentRole));
+    }
+    
+EXPORT_C TInt COmxILDummyBaseILIF::SetComponentIfRole(const TDesC8& /*aComponentRole*/)
+    {
+    return (KErrNotSupported);
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::GetComponentIfRole(TUid& aComponentRole) const
+    {
+    return (iBody->GetIfRole(aComponentRole));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::GetComponentIfRole(TDes8& /*aComponentRole*/) const
+    {
+    return (KErrNotSupported);
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::SetExtConfig(const TDesC8& /*aParameterName*/, 
+                                                const TILStruct& /*aConfig*/, 
+                                                const MILComponentPortIf* /*aComponentPort*/)
+    {
+    // It should be implemented in the derived class
+	return (KErrNotSupported);
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::GetExtConfig(const TDesC8& /*aParameterName*/, 
+                                                TILStruct& /*aConfig*/, 
+                                                const MILComponentPortIf* /*aComponentPort*/) const
+    {
+    // It should be implemented in the derived class
+	return (KErrNotSupported);
+    }
+EXPORT_C TAny* COmxILDummyBaseILIF::CustomInterface(TUid aUid)
+    {
+    if (aUid == KUidILComponentIf)
+        {
+        MILComponentIf* componentIf = this;
+        return componentIf;
+        }
+    else        
+        {
+        return NULL;
+        }
+    }
+
+
+EXPORT_C TInt COmxILDummyBaseILIF::FillBufferDone(CMMFBuffer* aBuffer, 
+                                                  TInt aPortIndex)
+    {
+    return (iBody->FillBufferDone(aBuffer, aPortIndex));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::EmptyBufferDone(const CMMFBuffer* aBuffer, 
+                                                   TInt aPortIndex)
+    {
+    return (iBody->EmptyBufferDone(aBuffer, aPortIndex));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::EventHandler(OMX_EVENTTYPE aEvent, 
+                                                TUint32 aData1, 
+                                                TUint32 aData2, 
+                                                TAny* aExtraInfo)
+    {
+    return (iBody->EventHandler(aEvent, aData1, aData2, aExtraInfo));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::OmxGetParameter(OMX_INDEXTYPE aParamIndex, 
+                                                   TAny* aComponentParameterStructure) const
+    {
+    return (iBody->OmxGetParameter(aParamIndex, aComponentParameterStructure));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::OmxSetParameter(OMX_INDEXTYPE aParamIndex, 
+                                                   TAny* aComponentParameterStructure)
+    {
+    return (iBody->OmxSetParameter(aParamIndex, aComponentParameterStructure));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::OmxGetConfig(OMX_INDEXTYPE aConfigIndex, 
+                                                TAny* aValue) const
+    {
+    return (iBody->OmxGetConfig(aConfigIndex, aValue));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::OmxSetConfig(OMX_INDEXTYPE aConfigIndex, 
+                                                TAny* aValue)
+    {
+    return (iBody->OmxSetConfig(aConfigIndex, aValue));
+    }
+
+EXPORT_C TInt COmxILDummyBaseILIF::OmxGetExtensionIndex(const TDesC8& aParameterName, 
+                                                        OMX_INDEXTYPE* aIndexType) const
+    {
+    return (iBody->OmxGetExtensionIndex(aParameterName, aIndexType));
+    }
+
+TInt COmxILDummyBaseILIF::OmxSendCommand(OMX_COMMANDTYPE aCmd, 
+                                         TUint32 aParam1, 
+                                         TAny* aCmdData)
+    {
+    return (iBody->OmxSendCommand(aCmd, aParam1, aCmdData));
+    }
+
+TInt COmxILDummyBaseILIF::OmxComponentTunnelRequest(TUint32 aPortInput, 
+                                                    OMX_HANDLETYPE aOutput, 
+                                                    TUint32 aPortOutput)
+    {
+    return (iBody->OmxComponentTunnelRequest(aPortInput, aOutput, aPortOutput));
+    }
+
+TInt COmxILDummyBaseILIF::OmxComponentDisconnectTunnel(TUint32 aPortInput, 
+												    OMX_HANDLETYPE aOutput, 
+												    TUint32 aPortOutput)
+	{
+	return (iBody->OmxComponentDisconnectTunnel(aPortInput, aOutput, aPortOutput));
+	}
+
+TInt COmxILDummyBaseILIF::OmxUseBuffer(CMMFBuffer* aBuffer, 
+                                       TUint32 aPortIndex)
+    {
+    return (iBody->OmxUseBuffer(aBuffer, aPortIndex));
+    }
+
+CMMFBuffer* COmxILDummyBaseILIF::OmxAllocateBufferL(TUint32 aPortIndex, 
+                                                    TUint32 aSizeBytes)
+    {
+    return (iBody->OmxAllocateBufferL(aPortIndex, aSizeBytes));
+    }
+
+TInt COmxILDummyBaseILIF::OmxFreeBuffer(CMMFBuffer* aBuffer)
+    {
+    return (iBody->OmxFreeBuffer(aBuffer));
+    }
+
+TInt COmxILDummyBaseILIF::OmxEmptyThisBuffer(const CMMFBuffer* aBuffer, 
+                                             MOmxILComponentIfObserver* aObserver)
+    {
+    return (iBody->OmxEmptyThisBuffer(aBuffer, aObserver));
+    }
+
+TInt COmxILDummyBaseILIF::OmxFillThisBuffer(CMMFBuffer* aBuffer, 
+                                            MOmxILComponentIfObserver* aObserver)
+    {
+    return (iBody->OmxFillThisBuffer(aBuffer, aObserver));
+    }
+
+OMX_COMPONENTTYPE* COmxILDummyBaseILIF::OmxHandle() const
+    {
+    return (iBody->Handle());    
+    }