serviceproviders/sapi_mediamanagement/tsrc/dev/tmediamgmtprovidertest/src/mediamgmtblocks.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 the License "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: ?Description
*
*/
// INCLUDE FILES
#include <e32svr.h>
#include <StifParser.h>
#include <StifTestInterface.h>
#include <liwservicehandler.h>
#include "mediamgmt.h"
using namespace LIW;
_LIT8(KGetList,"GetList");
//Just for comparison with cfg file
_LIT8(KNull8,"NULL");
_LIT(KNull,"NULL");
//Input Keys/arguments
_LIT8(KDsName,"Type");// used by interface class
_LIT8(KFileType,"FileType");
_LIT8(KKey,"Key");
_LIT8(KStartRange,"StartRange");
_LIT8(KEndRange,"EndRange");
_LIT8(KOrder,"Order");
// Filter Map
_LIT8(KFilter,"Filter");
// Sorting Map
_LIT8(KSort,"Sort");
//Output Keys/arguments
_LIT8(KErrorCode,"ErrorCode");
_LIT8(KResponse,"ReturnValue");
_LIT8(KService, "Service.MediaManagement");
_LIT8(KIDataSource,"IDataSource");
_LIT8(KTransactionID,"TransactionID");
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CMediaMgmt::Delete
// Delete here all resources allocated and opened from test methods.
// Called from destructor.
// -----------------------------------------------------------------------------
//
void CMediaMgmt::Delete()
{
}
// -----------------------------------------------------------------------------
// CMediaMgmt::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt CMediaMgmt::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( "InterfaceClass", CMediaMgmt::InterfaceClassL ),
};
const TInt count = sizeof( KFunctions ) /
sizeof( TStifFunctionInfo );
return RunInternalL( KFunctions, count, aItem );
}
// -----------------------------------------------------------------------------
// CMediaMgmt::ExampleL
// Example test method function.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CMediaMgmt::InterfaceClassL( CStifItemParser& aItem )
{
_LIT( KExample, "In InterfaceClass" );
iLog->Log( KExample );
struct ParamPass* arg1 = new ParamPass();
arg1->it = &aItem;
TRequestStatus Status = KRequestPending ;
RThread FunctionThread ;
//creating the thread , this thread is reponsible for sending the request to SAPI
TInt ret = FunctionThread.Create( _L("FunctionThread1"), ThreadFunction ,KDefaultStackSize ,
NULL ,( TAny * ) arg1);
User::LeaveIfError(ret);
FunctionThread.Logon(Status);
FunctionThread.Resume() ;
// Waiting for thread to die in other words we are making asynch call to synch call :-))
User :: WaitForRequest (Status) ;
FunctionThread.Close();
delete arg1;
return Status.Int() ;
}
// -----------------------------------------------------------------------------
// Callback:: HandleNotifyL
// Call Back Function Called by the Media Management SAPI.
// -----------------------------------------------------------------------------
//
TInt Callback:: HandleNotifyL(TInt /*aCmdId*/,TInt aEventId,CLiwGenericParamList& aOutParamList,const CLiwGenericParamList& /*aInParamList*/)
{
if ( KLiwEventStarted == aEventId )
{
arg->log->Log(_L(" Started Event Capture "));
// Asynchronous request started
}
else if ( KLiwEventCanceled == aEventId )
{
// Asynchronous event canceled
arg->log->Log(_L("Cancel Event Capture "));
User::Exit( KErrNone );
}
else if( KLiwEventError == aEventId)
{
// Error occurs in Asynchronous operation
arg->log->Log(_L(" Error Event Capture "));
User::Exit( KErrGeneral );
}
else
{
TInt32 ErrCode = KErrNone;
CLiwIterable* iIterable;
TLiwVariant Map;
const CLiwMap* MetaData;
TInt pos = 0;
// Traiverse the List and Fill in the Log Files
const TLiwGenericParam* p = aOutParamList.FindFirst(pos, KErrorCode); // Finding Error Code
if( p )
{
ErrCode = p->Value().AsTInt32();
}
else
{
arg->log->Log(_L(" Not able to Find the Error Code "));
CActiveScheduler :: Stop() ;
User::Exit( KErrGeneral );
}
if(ErrCode < 0 ) // If any error comes in MG SAPI
{
arg->log->Log(_L(" Error Occured in SAPI = %d"),ErrCode);
CActiveScheduler :: Stop() ;
User::Exit( KErrGeneral );
}
p = aOutParamList.FindFirst(pos, KResponse);// Finding out the response of Media Management
if(!p)
{
arg->log->Log(_L(" Not able to Find the Response "));
CActiveScheduler :: Stop() ;
User::Exit( KErrGeneral );
}
else
{
iIterable = p->Value().AsIterable();// returning Iterator as Response
TBuf8<30> Key;// Key In The Map
TPtrC KeyValue;// value of that key
TLiwVariant val;//just for extracting the value
//-----------Loop for Iterator -------------------------------//
TBuf<200> Output;
int count =0;
while(iIterable->NextL(Map))// Find the next value from Iterator
{
count++;
Output.Copy(_L("\n\nFile\n"));
arg->log->Log(Output);
MetaData = Map.AsMap();// Iterator return the map which contains meta data
Output.Copy(_L("key"));
Output.Append(_L(" "));
Output.Append(_L("KeyValue"));
arg->log->Log(Output);
for(TInt i = 0 ; i <MetaData->Count(); i++ )
{
MetaData->AtL(i,Key);
MetaData->FindL(Key, val);
Key.Trim();
Output.Copy(Key);
Output.Append(_L(" "));
if(EVariantTypeTInt32==val.TypeId())
{
TInt value = val.AsTInt32();
TBuf<30> string;
string.AppendNum(value);
string.Trim();
Output.Append(string);
}
else if(EVariantTypeTTime==val.TypeId())
{
TTime time = val.AsTTime();
_LIT(KTimeFormat,"%F%M/%D/%Y %H:%T");
TBuf <20> StringTime;
time.FormatL(StringTime, KTimeFormat);
StringTime.Trim();
Output.Append(StringTime);
// date format : 5/25/2005 12:40"
}
else
{
val.Get(KeyValue);
// KeyValue.Trim();
Output.Append(KeyValue);
}
arg->log->Log(Output); // printing Key Values in log files
}
Map.Reset();
}
}
//------Loop for Iterator-----------------------------------------//
CActiveScheduler :: Stop() ;
}
return 0;
}
// -----------------------------------------------------------------------------
// Thread Function For Sending the Asynch request to Media Management SAPI
// -----------------------------------------------------------------------------
//
TInt ThreadFunction (TAny *a)
{
// Creating the Cleanup stack for this new thread
CTrapCleanup* cleanup = CTrapCleanup::New();
struct ParamPass* arg1 = (ParamPass*) a;
TInt errorCode = 0;
TInt error = KErrNone;
TInt expectedResult;
TRAP(error, errorCode = GetFilesAsynchL(a));
delete cleanup;
if( arg1->it->GetNextInt(expectedResult) != KErrNone )
{
arg1->log->Log(_L("Failed to Get the Sorting Order ")) ;
return KErrGeneral;
}
if(error == KErrNone)
{
if(errorCode>0)
{
arg1->log->Log(_L(" Error in input "));
TBuf<30> string;
string.AppendNum(errorCode);
arg1->log->Log(string);
delete arg1->log;
if( expectedResult != 0)//negative test case
{
return KErrNone;
}
return KErrGeneral;
}
else
{
return KErrNone;
}
}
return KErrGeneral;
}
TInt GetFilesAsynchL( TAny *a)
{
TPtrC cfgCommand16;
TPtrC cfgDataSourceName;
TPtrC FileType16;
TPtrC FilterField16;
TPtrC StartVal;
TPtrC EndVal;
TPtrC SortField16;
TPtrC order;
TInt expectedResult = 0;
TInt operation = 0;
struct ParamPass *arg1 = (ParamPass *)a;
arg1->log = CStifLogger::NewL( KMediaMgmtLogPath,
KResultFile,
CStifLogger::ETxt,
CStifLogger::EFile,
ETrue,
EFalse);
// Get All the Values From CFG file
if( arg1->it->GetNextString ( cfgCommand16 ) != KErrNone )
{
arg1->log->Log(_L(" Failed to Get the File Type ") );
return KErrGeneral;
}
if( arg1->it->GetNextString ( cfgDataSourceName ) != KErrNone )
{
arg1->log->Log(_L(" Failed to Get the File Type ") );
return KErrGeneral;
}
if( arg1->it->GetNextString ( FileType16 ) != KErrNone )
{
arg1->log->Log(_L(" Failed to Get the File Type ") );
return KErrGeneral;
}
if( arg1->it->GetNextString ( FilterField16 ) != KErrNone )
{
arg1->log->Log(_L("Failed to Get the Filter Field of File ")) ;
return KErrGeneral;
}
if( arg1->it->GetNextString ( StartVal ) != KErrNone )
{
arg1->log->Log(_L("Failed to Get the start value of Filter ")) ;
return KErrGeneral;
}
if( arg1->it->GetNextString ( EndVal ) != KErrNone )
{
arg1->log->Log(_L("Failed to Get the End Value of Filter ")) ;
return KErrGeneral;
}
if( arg1->it->GetNextString ( SortField16 ) != KErrNone )
{
arg1->log->Log(_L("Failed to Get the Sort Filed ")) ;
return KErrGeneral;
}
if( arg1->it->GetNextString(order) != KErrNone )
{
arg1->log->Log(_L("Failed to Get the Sorting Order ")) ;
return KErrGeneral;
}
if( arg1->it->GetNextInt(operation) != KErrNone )
{
arg1->log->Log(_L("Failed to Get the Sorting Order ")) ;
return KErrGeneral;
}
// the below section for giving header to log files
TBuf<200> TestCase;
TestCase.Copy(_L("FileType "));
TestCase.Append(_L(" "));
TestCase.Append(_L("FilterField"));
TestCase.Append(_L(" "));
TestCase.Append(_L("StartVal"));
TestCase.Append(_L(" "));
TestCase.Append(_L("EndVal"));
TestCase.Append(_L(" "));
TestCase.Append(_L("SortField"));
TestCase.Append(_L(" "));
TestCase.Append(_L("order"));
TestCase.Append(_L(" "));
arg1->log->Log(TestCase);
TestCase.Copy(FileType16);
TestCase.Append(_L(" "));
TestCase.Append(FilterField16);
TestCase.Append(_L(" "));
TestCase.Append(StartVal);
TestCase.Append(_L(" "));
TestCase.Append(EndVal);
TestCase.Append(_L(" "));
TestCase.Append(SortField16);
TestCase.Append(_L(" "));
TestCase.Append(order);
TestCase.Append(_L(" "));
arg1->log->Log(TestCase);
// Convert 16 Bit values into 8 bit as SAPI accept 8 bit key
TBuf8<30> Command ;
Command.Copy(cfgCommand16);
TBuf8<30> FileType ;
//FileType.Copy(FileType16);
TBuf8<30> FilterField ;
//FilterField.Copy(FilterField16);
TBuf8<30> SortField ;
//SortField.Copy(SortField16);
TBuf8<30> Order ;
//Order.Copy(order);
CLiwGenericParamList* input = CLiwGenericParamList::NewL();
CleanupStack::PushL(input);
// Start Scheduler
CActiveScheduler *Scheduler = new (ELeave) CActiveScheduler ;
CActiveScheduler :: Install(Scheduler) ;
CleanupStack::PushL(Scheduler);
CLiwServiceHandler* iServiceHandler = CLiwServiceHandler::NewL();
CleanupStack::PushL(iServiceHandler);
CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1,KIDataSource,KService);
crit->SetServiceClass(TUid::Uid(KLiwClassBase));
CleanupStack::PushL(crit);
RCriteriaArray critArray;
critArray.AppendL(crit);
CleanupClosePushL(critArray);
iServiceHandler->AttachL(critArray);
//Create the object of callback
MLiwNotifyCallback* aCallBack = new (ELeave) Callback(arg1);
CleanupStack::PushL(aCallBack);
CLiwGenericParamList* output = CLiwGenericParamList::NewL();
CleanupStack::PushL(output);
iServiceHandler->ExecuteServiceCmdL(*crit, *input, *output);
// Create the Instance of SAPI class and the Input Param and output Param
TInt pos = 0;
MLiwInterface* Interface = NULL;
output->FindFirst(pos,KIDataSource );
if(pos != KErrNotFound)
{
Interface = (*output)[pos].Value().AsInterface();
}
output->Reset();
input->Reset();
//MLiwInterface* Interface = CMgDataSourceInterface::NewL();
CleanupClosePushL(*Interface);
if( 0 != cfgDataSourceName.CompareF(KNull) )
{
TLiwVariant dsName;
dsName.Set(cfgDataSourceName);
TLiwGenericParam dsNameParam(KDsName, dsName);
input->AppendL(dsNameParam);
}
CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
TLiwGenericParam iFilterParam(KFilter, TLiwVariant(filterMap));
input->AppendL(iFilterParam);
filterMap->DecRef();
CLiwDefaultMap *sortingMap = CLiwDefaultMap::NewL();
TLiwGenericParam iSortingParam(KSort, TLiwVariant(sortingMap));
input->AppendL(iSortingParam);
sortingMap->DecRef();
//Inserting data source name
//------Send all this thing in Filter Map -------------------------------//
if( 0 != FileType16.CompareF( KNull ) )
{
TLiwVariant ifileType;
//ifileType.Set(FileType);
ifileType.Set(FileType16);
filterMap->InsertL(KFileType,ifileType);
}
if( 0 != FilterField16.CompareF( KNull ) )
{
TLiwVariant iFilterField;
//iFilterField.Set(FilterField);
iFilterField.Set(FilterField16);
filterMap->InsertL(KKey,iFilterField);
}
if( 0 != StartVal.CompareF( KNull ) )
{
TLiwVariant iStartVal;
iStartVal.Set(StartVal);
filterMap->InsertL(KStartRange,iStartVal);
}
if( 0 != EndVal.CompareF( KNull ) )
{
TLiwVariant iEndVal;
iEndVal.Set(EndVal);
filterMap->InsertL(KEndRange,iEndVal);
}
//------------------Send all the below in sorting map----------------------------------------------------------//
if( 0 != SortField16.CompareF( KNull ) )
{
TLiwVariant iSortField;
//iSortField.Set(SortField);
iSortField.Set(SortField16);
sortingMap->InsertL(KKey,iSortField);
}
if( 0 != order.CompareF( KNull ) )
{
TLiwVariant iOrder;
//iOrder.Set(Order);
iOrder.Set(order);
sortingMap->InsertL(KOrder,iOrder);
}
const TLiwGenericParam* p= NULL;
//---------------------------------------------------------------------------------//
if( operation == 0)
{
// normal asynch operation
if( Interface != NULL)
Interface->ExecuteCmdL(Command,*input,*output,KLiwOptASyncronous,aCallBack);
}
else if(operation == 1)
{
//cancel
Interface->ExecuteCmdL(Command,*input,*output,KLiwOptASyncronous,aCallBack);
pos = 0;
p = output->FindFirst(pos, KTransactionID); // Finding Error Code
input->Reset();
TUint transactionID = 0;
if( p )
{
p->Value().Get(transactionID);
input->AppendL( TLiwGenericParam( KTransactionID, TLiwVariant( transactionID ) ) );
}
Interface->ExecuteCmdL(_L8("Cancel"),*input,*output,KLiwOptCancel,aCallBack);
}
else if( operation == 3)
{
// check back to back request
Interface->ExecuteCmdL(Command,*input,*output,KLiwOptASyncronous,aCallBack);
Interface->ExecuteCmdL(Command,*input,*output,KLiwOptASyncronous,aCallBack);
Interface->ExecuteCmdL(Command,*input,*output,KLiwOptCancel,aCallBack);
}
else if(operation == 4)
{
Interface->Close();
CleanupStack::Pop();
CleanupStack::PopAndDestroy(7);
return KErrNone;
}
else if(operation == 5) // Stress testing: Calling getlist n number of times
{
TInt no_of_times;
TInt retcode = KErrNone;
arg1->it->GetNextInt(no_of_times);
for (int i=0;i<no_of_times;i++)
{
if( Interface != NULL)
output->Reset();
Interface->ExecuteCmdL(Command,*input,*output,KLiwOptASyncronous,aCallBack);
_LIT8(KErrorCode,"ErrorCode");
pos = 0;
TInt retcode;
p = output->FindFirst(pos, KErrorCode); // Finding Error Code
TUint transactionID = 0;
if(p)
{
retcode = p->Value().AsTInt32();
if(retcode != KErrNone)
{
CleanupStack::PopAndDestroy(); //.sorting Map,filterMap,Interface,input, output, Scheduler,aCallBack
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
return retcode;
}
else
{
CActiveScheduler :: Start() ;
}
}
else
{
CleanupStack::PopAndDestroy(input);
return KErrGeneral ;
}
}
CleanupStack::PopAndDestroy(8);
return KErrNone;
}
else if(operation == 6) // Loading twice
{
// normal asynch operation
if( Interface != NULL)
Interface->ExecuteCmdL(Command,*input,*output,KLiwOptASyncronous,aCallBack);
_LIT8(KErrorCode,"ErrorCode");
pos = 0;
TInt retcode = KErrNone;
p = output->FindFirst(pos, KErrorCode); // Finding Error Code
if(p)
{
retcode = p->Value().AsTInt32();
if(retcode != KErrNone)
{
CleanupStack::PopAndDestroy(); //.sorting Map,filterMap,Interface,input, output, Scheduler,aCallBack
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
return retcode;
}
}
CActiveScheduler :: Start() ;
CleanupStack::PopAndDestroy(7); //Interface ,input, output, coreobj, Scheduler,aCallBack
CActiveScheduler *Scheduler = new (ELeave) CActiveScheduler ;
CActiveScheduler :: Install(Scheduler) ;
CleanupStack::PushL(Scheduler);
CLiwServiceHandler* iServiceHandler = CLiwServiceHandler::NewL();
CleanupStack::PushL(iServiceHandler);
CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1,KIDataSource,KService);
crit->SetServiceClass(TUid::Uid(KLiwClassBase));
CleanupStack::PushL(crit);
RCriteriaArray critArray;
critArray.AppendL(crit);
CleanupClosePushL(critArray);
iServiceHandler->AttachL(critArray);
//Create the object of callback
MLiwNotifyCallback* aCallBack = new (ELeave) Callback(arg1);
CleanupStack::PushL(aCallBack);
CLiwGenericParamList* output = CLiwGenericParamList::NewL();
CleanupStack::PushL(output);
iServiceHandler->ExecuteServiceCmdL(*crit, *input, *output);
// Create the Instance of SAPI class and the Input Param and output Param
TInt pos = 0;
MLiwInterface* Interface = NULL;
output->FindFirst(pos,KIDataSource );
if(pos != KErrNotFound)
{
Interface = (*output)[pos].Value().AsInterface();
}
output->Reset();
CleanupClosePushL(*Interface);
// normal asynch operation
if( Interface != NULL)
Interface->ExecuteCmdL(Command,*input,*output,KLiwOptASyncronous,aCallBack);
}
else
{
// synchronous
Interface->ExecuteCmdL(Command,*input,*output,0,aCallBack);
}
_LIT8(KErrorCode,"ErrorCode");
pos = 0;
TInt retcode = KErrNone;
p = output->FindFirst(pos, KErrorCode); // Finding Error Code
if(p)
{
retcode = p->Value().AsTInt32();
if(retcode != KErrNone)
{
CleanupStack::PopAndDestroy(); //.sorting Map,filterMap,Interface,input, output, Scheduler,aCallBack
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
return retcode;
}
}
CActiveScheduler :: Start() ;
CleanupStack::PopAndDestroy(8); //Interface ,input, output, coreobj, Scheduler,aCallBack
return retcode ;
}