mds_plat/harvester_framework_api/tsrc/HarvesterPluginTest/src/HarvesterPluginTestBlocks.cpp
/*
* Copyright (c) 2002 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 <StifTestEventInterface.h>
#include <StifTestInterface.h>
#include "HarvesterPluginTest.h"
#include "mdsutils.h"
#include "harvesterblacklist.h"
#include "mdeobject.h"
#include "mdeobjecthandler.h"
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::Delete
// Delete here all resources allocated and opened from test methods.
// Called from destructor.
// -----------------------------------------------------------------------------
//
void CHarvesterPluginTest::Delete()
{
}
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt CHarvesterPluginTest::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( "BeginTestSession", CHarvesterPluginTest::BeginTestSessionL ),
ENTRY( "EndTestSession", CHarvesterPluginTest::EndTestSession ),
ENTRY( "LoadPlugins", CHarvesterPluginTest::LoadPluginsL ),
ENTRY( "TestFunctions", CHarvesterPluginTest::TestFunctionsL ),
};
const TInt count = sizeof( KFunctions ) /
sizeof( TStifFunctionInfo );
return RunInternalL( KFunctions, count, aItem );
}
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::HandleSessionOpened
// -----------------------------------------------------------------------------
//
void CHarvesterPluginTest::HandleSessionOpened( CMdESession& /*aClient*/, TInt aError )
{
_LIT( KMsg, "CallBck HandleSessionOpened - Error code : %d" );
TBuf <100> msg;
msg.Format(KMsg, aError);
iLog->Log( msg );
RDebug::Print(msg);
TRAP_IGNORE( iMdeObjectHandler = CMdeObjectHandler::NewL( *iMdeSession ) );
// session event
TEventIf event( TEventIf::ESetEvent, _L("Session") );
TestModuleIf().Event( event );
}
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::HandleSessionError
// -----------------------------------------------------------------------------
//
void CHarvesterPluginTest::HandleSessionError( CMdESession& /*aClient*/, TInt aError )
{
_LIT( KMsg, "CallBck HandleSessionError - Error code : %d" );
TBuf <100> msg;
msg.Format(KMsg, aError);
iLog->Log( msg );
RDebug::Print(msg);
// session event
TEventIf event( TEventIf::ESetEvent, _L("Session") );
TestModuleIf().Event( event );
}
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::HarvestingCompleted
// -----------------------------------------------------------------------------
//
void CHarvesterPluginTest::HarvestingCompleted( CHarvesterData* /* aHarvesterData */ )
{
// harvest event
TEventIf event( TEventIf::ESetEvent, _L("Harvest") );
TestModuleIf().Event( event );
}
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::BeginTestSessionL
// -----------------------------------------------------------------------------
//
TInt CHarvesterPluginTest::BeginTestSessionL( CStifItemParser& /* aItem */ )
{
TRAPD( error, iMdeSession = CMdESession::NewL( *this ) );
iSession = CMdEHarvesterSession::NewL( *iMdeSession );
iCtxEngine = NULL;
iBlacklist = CHarvesterBlacklist::NewL();
_LIT( KMsg, "Exit BeginTestSession - Error code : %d" );
TBuf <100> msg;
msg.Format(KMsg, error);
iLog->Log( msg );
RDebug::Print( msg );
User::LeaveIfError( error );
return KErrNone;
}
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::EndTestSession
// -----------------------------------------------------------------------------
//
TInt CHarvesterPluginTest::EndTestSession( CStifItemParser& /* aItem */ )
{
iPluginInfoArray.ResetAndDestroy();
iPluginInfoArray.Close();
REComSession::FinalClose();
if ( iCtxEngine )
{
iCtxEngine->ReleaseInstance();
iCtxEngine = NULL;
}
if ( iBlacklist )
{
iBlacklist->CloseDatabase();
delete iBlacklist;
}
if ( iSession )
{
delete iSession;
iSession = NULL;
}
if ( iMdeObjectHandler )
{
delete iMdeObjectHandler;
iMdeObjectHandler = NULL;
}
if( iMdeSession )
{
delete iMdeSession;
iMdeSession = NULL;
}
_LIT( KMsg, "Exit EndTestSession" );
iLog->Log( KMsg );
RDebug::Print(KMsg);
return KErrNone;
}
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::LoadPluginsL
// -----------------------------------------------------------------------------
//
TInt CHarvesterPluginTest::LoadPluginsL( CStifItemParser& /* aItem */ )
{
_LIT( KMsg1, "Enter LoadPlugins" );
iLog->Log( KMsg1 );
RDebug::Print( KMsg1 );
RImplInfoPtrArray infoArray;
TCleanupItem cleanupItem( MdsUtils::CleanupEComArray, &infoArray );
CleanupStack::PushL( cleanupItem );
CHarvesterPlugin::ListImplementationsL( infoArray );
TInt count( 0 );
count = infoArray.Count();
if( count == 0 )
{
return KErrNotFound;
}
for ( TInt i=0; i < count; i++ )
{
// Parse the file extensions and resolve plug-in's uids from infoArray to iDataTypeArray
TBufC8<256> type;
TBufC8<256> opaque;
type = infoArray[i]->DataType();
opaque = infoArray[i]->OpaqueData();
TUid implUID = infoArray[i]->ImplementationUid();
AddNewPluginL(type, opaque, implUID);
}
CleanupStack::PopAndDestroy( &infoArray ); // infoArray, results in a call to CleanupEComArray
_LIT( KMsg2, "Exit LoadPlugins" );
iLog->Log( KMsg2 );
RDebug::Print( KMsg2 );
return KErrNone;
}
// -----------------------------------------------------------------------------
// CHarvesterPluginTest::TestFunctionsL
// -----------------------------------------------------------------------------
//
TInt CHarvesterPluginTest::TestFunctionsL( CStifItemParser& aItem )
{
_LIT( KMsg1, "Enter TestFunctions" );
iLog->Log( KMsg1 );
RDebug::Print( KMsg1 );
TPtrC inputFile;
User::LeaveIfError( aItem.GetNextString( inputFile ) );
iMdeSession->RemoveObjectL( inputFile );
TBuf<100> aObjectDef;
GetObjectDef( inputFile, aObjectDef, EFalse );
// harvesterdata object
HBufC* uriBuf = inputFile.AllocLC();
CHarvesterData* data = CHarvesterData::NewL( uriBuf );
data->SetPluginObserver( *this );
CMdEObject* mdeObject = NULL;
_LIT( string, "Image" );
mdeObject = iMdeObjectHandler->GetMetadataObjectL( *data, string );
data->SetMdeObject( mdeObject );
CleanupStack::Pop( uriBuf );
HarvestL( data );
_LIT( KMsg2, "Exit TestFunctions" );
iLog->Log( KMsg2 );
RDebug::Print( KMsg2 );
return KErrNone;
}
// ---------------------------------------------------------------------------
// GetObjectDef
// ---------------------------------------------------------------------------
//
TBool CHarvesterPluginTest::GetObjectDef(const TDesC& aUri, TDes& aObjectDef, TBool aCheck)
{
CHarvesterPluginInfo* hpi = NULL;
TRAPD( err, hpi = GetHPIFromFileNameL(aUri) );
if ( err != KErrNone )
{
aObjectDef.Zero();
return EFalse;
}
if ( !hpi )
{
aObjectDef.Zero();
}
else
{
if( hpi->iObjectTypes.Count() > 1)
{
if( aCheck )
{
aObjectDef.Zero();
return ETrue;
}
if ( ! hpi->iPlugin )
{
TRAPD( error, hpi->iPlugin = CHarvesterPlugin::NewL( hpi->iPluginUid ) );
if( error )
{
aObjectDef.Zero();
return EFalse;
}
else
{
hpi->iPlugin->SetQueue( hpi->iQueue );
}
}
hpi->iPlugin->GetObjectType( aUri, aObjectDef );
}
else
{
aObjectDef.Copy( *(hpi->iObjectTypes[0]) );
}
}
return EFalse;
}
// ---------------------------------------------------------------------------
// HarvestL
// ---------------------------------------------------------------------------
//
TInt CHarvesterPluginTest::HarvestL( CHarvesterData* aHD )
{
_LIT( KMsg1, "Enter HarvestL" );
iLog->Log( KMsg1 );
RDebug::Print( KMsg1 );
CHarvesterPluginInfo* hpi = aHD->HarvesterPluginInfo();
if ( !hpi )
{
hpi = GetHPIFromFileNameL( aHD->Uri() );
}
if ( hpi )
{
if ( ! hpi->iPlugin )
{
hpi->iPlugin = CHarvesterPlugin::NewL( hpi->iPluginUid );
hpi->iPlugin->SetQueue( hpi->iQueue );
hpi->iPlugin->SetBlacklist( *iBlacklist );
}
if( aHD->ObjectType() == EFastHarvest || aHD->Origin() == MdeConstants::Object::ECamera )
{
hpi->iQueue.Insert( aHD, 0 );
}
else
{
hpi->iQueue.AppendL( aHD );
}
hpi->iPlugin->StartHarvest();
_LIT( KMsg2, "Exit HarvestL" );
iLog->Log( KMsg2 );
RDebug::Print( KMsg2 );
return KErrNone;
}
return KErrNotFound;
}
// -----------------------------------------------------------------------------
// AddNewPluginL
// -----------------------------------------------------------------------------
//
void CHarvesterPluginTest::AddNewPluginL( const TDesC8& aType, const TDesC8& aOpaque, TUid aPluginUid )
{
CHarvesterPluginInfo* pluginInfo = new (ELeave) CHarvesterPluginInfo;
CleanupStack::PushL( pluginInfo );
// get file extensions
TLex8 lex( aOpaque );
while ( !lex.Eos() )
{
/* Tokenizing file extensions using TLex8 */
lex.SkipSpaceAndMark();
TPtrC8 extToken = lex.NextToken();
HBufC* str = HBufC::NewLC( extToken.Length() );
str->Des().Copy( extToken );
pluginInfo->iExtensions.AppendL( str );
CleanupStack::Pop( str );
}
// get object types
TLex8 lexObjectTypes( aType );
while ( !lexObjectTypes.Eos() )
{
/* Tokenizing object types using TLex8 */
lexObjectTypes.SkipSpaceAndMark();
TPtrC8 objectTypeToken = lexObjectTypes.NextToken();
HBufC* str = HBufC::NewLC( objectTypeToken.Length() );
str->Des().Copy( objectTypeToken );
pluginInfo->iObjectTypes.AppendL( str );
CleanupStack::Pop( str );
}
/* We set plugin as NULL - we only load them when needed */
pluginInfo->iPlugin = NULL;
pluginInfo->iPluginUid = aPluginUid;
iPluginInfoArray.AppendL( pluginInfo );
CleanupStack::Pop( pluginInfo );
}
// ---------------------------------------------------------------------------
// GetHPIFromFileNameL
// ---------------------------------------------------------------------------
//
CHarvesterPluginInfo* CHarvesterPluginTest::GetHPIFromFileNameL(const TDesC& aFileName)
{
_LIT( KMsg1, "Enter GetHPIFromFileNameL" );
iLog->Log( KMsg1 );
RDebug::Print( KMsg1 );
TParsePtrC parser( aFileName );
// without trailing dot "."
TPtrC ptr = parser.Ext();
if ( ptr.Length() > 1 )
{
ptr.Set( ptr.Mid( 1 ) );
}
_LIT( KMsg2, "Exit GetHPIFromFileNameL" );
iLog->Log( KMsg2 );
RDebug::Print( KMsg2 );
return GetFromNormalFileL( ptr );
}
// ---------------------------------------------------------------------------
// GetFromNormalFile
// ---------------------------------------------------------------------------
//
CHarvesterPluginInfo* CHarvesterPluginTest::GetFromNormalFileL( TDesC& aExt )
{
_LIT( KMsg1, "Enter GetFromNormalFileL" );
iLog->Log( KMsg1 );
RDebug::Print( KMsg1 );
CHarvesterPluginInfo* retVal = NULL;
for ( TInt i = iPluginInfoArray.Count(); --i >= 0; )
{
CHarvesterPluginInfo* info = iPluginInfoArray[i];
TBool found = EFalse;
for ( TInt k = info->iExtensions.Count(); --k >= 0; )
{
TDesC* ext = info->iExtensions[k];
// checking against supported plugin file extensions
TInt result = ext->CompareF( aExt );
if ( result == 0 )
{
retVal = info;
found = ETrue;
break;
}
}
if ( found )
{
break;
}
}
_LIT( KMsg2, "Exit GetFromNormalFileL" );
iLog->Log( KMsg2 );
RDebug::Print( KMsg2 );
return retVal;
}
// [End of File] - Do not remove