// start run a test case
void CTestExecutor::RunTestCaseL()
{
RSemaphore smphF;
smphF.CreateLocal(0);
RSemaphore smphN;
smphN.CreateLocal(0);
RArray<RThread> notiThreads; // list of handles of notification threads
RPointerArray<CTimerLogger> loggerList;
TUint16 count = 0;
TUint16 option = iTestSetting.iOption;
while (count < iTestSetting.iNumCli)
{
test(count < 16);
iTestSetting.iOption = (TUint16)(option + count); // Put Thread ID in option
TThreadParam param;
param.iSetting = iTestSetting;
param.iSmphFT = &smphF;
param.iSmphNT = &smphN;
TFileName logName;
logName.FillZ();
if (gPerfMeasure)
{
logName.Append(gLogFilePath);
if (iTestSetting.iNumCli == 1)
logName.Append(_L("SingleClient"));
else
logName.AppendFormat(_L("MultiClient%02d"), count);
logName.Append(gLogPostFix);
}
CTimerLogger* logger = CTimerLogger::NewL(logName);
CleanupStack::PushL(logger);
param.iLogger = logger;
param.iLoggerArray = NULL;
TUint operation = *iTestSetting.iOperationList;
TBool numFilesVaries = EFalse;
if (operation == EOpManyFiles || operation == EOpManyChanges || operation == EOpMixed)
{
numFilesVaries = ETrue;
}
logger->LogSettingDescription(iTestSetting.iNumFiles, iTestSetting.iNumCli, iTestSetting.iOption, numFilesVaries);
loggerList.AppendL(logger);
TBuf<20> threadName;
threadName.AppendFormat(_L("NotificationThread%02d"), count);
RThread notifyOp;
notifyOp.Create(threadName, NotificationOperationThread, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, ¶m);
notiThreads.AppendL(notifyOp);
notifyOp.Resume();
smphF.Wait(); // Wait for the parameters being properly passed
CleanupStack::Pop(logger);
count++;
}
gNotiThreads = notiThreads;
if (iTestSetting.iNumCli == 0) // no notification
{
TFileName logName;
logName.Append(gLogFilePath);
logName.Append(_L("SingleClient"));
logName.Append(gLogPostFix);
CTimerLogger* logger = CTimerLogger::NewL(logName);
CleanupStack::PushL(logger);
logger->LogSettingDescription(iTestSetting.iNumFiles, iTestSetting.iNumCli, iTestSetting.iOption);
loggerList.AppendL(logger);
CleanupStack::Pop(logger);
}
TThreadParam paramFileOp;
paramFileOp.iSetting = iTestSetting;
paramFileOp.iSmphFT = &smphF;
paramFileOp.iSmphNT = &smphN;
paramFileOp.iLogger = NULL;
paramFileOp.iLoggerArray = &loggerList;
RThread fileOp;
fileOp.Create(_L("FileOperationThread"), FileOperationThread, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, ¶mFileOp);
gFileThread = fileOp;
fileOp.Resume();
TInt err;
TRequestStatus status;
fileOp.Logon(status);
User::WaitForRequest(status);
err = fileOp.ExitReason();
test(err == KErrNone);
count = 0;
while(count < notiThreads.Count())
{
notiThreads[count].Logon(status);
User::WaitForRequest(status);
err = notiThreads[count].ExitReason();
test(err == KErrNone);
count++;
}
CLOSE_AND_WAIT(fileOp);
count = 0;
while(count < notiThreads.Count())
{
RThread thread = notiThreads[count];
CLOSE_AND_WAIT(thread);
count++;
}
for (TInt i = 0; i < loggerList.Count(); i++)
{
loggerList[i]->LogAndPrint(_L("===================================================="));
}
smphN.Close();
smphF.Close();
loggerList.ResetAndDestroy();
loggerList.Close();
notiThreads.Reset();
notiThreads.Close();
}
void CTzDbRuleSet::CompleteRulesAndAddToCollectionL(
CTzRules& aTzRules,
const RArray<TTzRuleDefinition*>& aRuleDefs,
const RArray<TTzRuleUse*>& aRuleUses,
TInt aUtcOffset, TInt aInitialLocalTimeOffset,
TDateTime aStart, TDateTime aEnd) const
{
TInt count = aRuleDefs.Count();
if (count != aRuleUses.Count())
{
User::Leave(KErrCorrupt);
}
TTimeWithReference startOfAlignment(aStart,ETzUtcTimeReference);
TTimeWithReference endOfAlignment(aEnd,ETzUtcTimeReference);
//Keep track of changes to UTC offset
// even if there are no DST rules.
TTzRule trule(
startOfAlignment, startOfAlignment,
(TUint16)aInitialLocalTimeOffset, (TUint16)aInitialLocalTimeOffset, EJanuary, ETzFixedDate,
0, 0,
ETzUtcTimeReference,
0);
aTzRules.AddRuleL(trule);
//Calculate the new and old offsets for each rule.
TInt prevOffset = 0;
TInt maxOffset = 0;
for (TInt i = 0; i < count; i++)
{
TInt oldOffset = aInitialLocalTimeOffset;
TInt dstOffset = aRuleDefs[i]->iStdTimeOffset;
TInt newOffset = aUtcOffset + dstOffset;
//newoffset and oldoffset should always have a difference of dstoffset.
if (newOffset <= oldOffset )
{
//there are cases when dstoffset in the set of rules is same for few continuous rules
//in such cases, newoffset and oldoffset would have a difference of maxoffset.
if(prevOffset == dstOffset)
{
oldOffset = aUtcOffset + maxOffset;
}
else
{
oldOffset = aUtcOffset + prevOffset;
}
}
else
//newoffset is more than oldoffset so maintain the difference with dstoffset.
{
oldOffset = newOffset - dstOffset;
}
prevOffset = dstOffset;
//store maximum offset, to handle cases in which dstoffset in the set of rules
//is same for few continuous rules
if(dstOffset > maxOffset)
{
maxOffset = dstOffset;
}
TUint16 timeOfChange = aRuleDefs[i]->iTimeOfChange;
TTzTimeReference timeReference =
static_cast<TTzTimeReference>(aRuleDefs[i]->iTimeReference);
//
// Find the intersection of the date ranges:
// use latest start year, earliest end year
TDateTime start = aStart;
TDateTime end = aEnd;
if(aRuleUses[i]->iFromYear > start.Year())
{
start = TDateTime(aRuleUses[i]->iFromYear,EJanuary,0,0,0,0,0);
}
if(aEnd.Year() > aRuleUses[i]->iUntilYear)
{
end = TDateTime(aRuleUses[i]->iUntilYear,EDecember,30,23,59,59,0);
}
TTimeWithReference startOfRule(start,ETzUtcTimeReference);
TTimeWithReference endOfRule(end,ETzUtcTimeReference);
if(endOfRule.iTime >= startOfRule.iTime)
{
TTzRule trule(
startOfRule, endOfRule,
(TUint16)oldOffset, (TUint16)newOffset, (TMonth)aRuleDefs[i]->iMonth, (TTzRuleDay)aRuleDefs[i]->iDayRule,
aRuleDefs[i]->iDayOfMonth, aRuleDefs[i]->iDayOfWeek,
timeReference, timeOfChange);
aTzRules.AddRuleL(trule);
}
}
}
QList<XQCentralRepositorySettingsKey> XQCentralRepositoryUtilsPrivate::findKeys(const XQCentralRepositorySearchCriteria& criteria)
{
long int repositoryUid = criteria.repositoryUid();
CCentralRepositoryHandler* handler = m_settingsManagerPrivate.cenRepHandlerInstance(repositoryUid);
if (!handler)
{
m_settingsManagerPrivate.iError = XQSettingsManager::UnknownError;
return QList<XQCentralRepositorySettingsKey>();
}
QList<XQCentralRepositorySettingsKey> keys;
TRAP(m_settingsManagerPrivate.iError,
RArray<TUint32> foundKeys;
CleanupClosePushL(foundKeys);
if (criteria.value().isNull())
{
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
foundKeys));
}
else
{
switch (criteria.value().type())
{
case QVariant::Int:
{
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
criteria.value().toInt(), criteria.negativeCriteria(), foundKeys));
break;
}
case QVariant::Double:
{
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
criteria.value().toDouble(), criteria.negativeCriteria(), foundKeys));
break;
}
case QVariant::String:
{
TPtrC16 stringValue(reinterpret_cast<const TUint16*>(criteria.value().toString().utf16()));
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
stringValue, criteria.negativeCriteria(), foundKeys));
break;
}
case QVariant::ByteArray:
{
TPtrC8 byteArrayValue((TUint8*)(criteria.value().toByteArray().constData()));
User::LeaveIfError(handler->findKeyL(criteria.partialKey(), criteria.bitMask(),
byteArrayValue, criteria.negativeCriteria(), foundKeys));
break;
}
default:
{
User::Leave(KErrArgument);
break;
}
}
}
for (int i = 0; i < foundKeys.Count(); ++i)
{
XQCentralRepositorySettingsKey key(repositoryUid, foundKeys[i]);
keys.append(key);
}
CleanupStack::PopAndDestroy(&foundKeys);
)
return keys;
// ---------------------------------------------------------------------------
// CAtSmsStoreReadAll::ParseResponseL
// other items were commented in a header
// ---------------------------------------------------------------------------
void CAtSmsStoreReadAll::ParseResponseL(const TDesC8& /*aResponseBuf*/)
{
/**
* Response:+CMGR:<stat>,[<alpha>],<length><CR><LF><pdu>
*/
iError = KErrNone;
RArray<TPtrC8> array;
CleanupClosePushL(array);
iParser->ParseRespondedBuffer(array,Buffer());
if(array[0].MatchF(KAnyATCommand)!=KErrNotFound)
{
array.Remove(0);
}
TInt count = array.Count();
#ifdef _DEBUG
for( TInt i=0;i<count;i++ )
{
LOGTEXT3(_L8("CAtSmsStoreReadAll::ParseResponseL\tarray[%d]=%S"),i,&array[i]);
}
#endif
if (count <= 1)
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
if(array[0].MatchF(KCMGRResponseString)==KErrNotFound)
{
LOGTEXT(_L8("CAtSmsStoreReadAll::ParseResponseL\tFound +CMGR String!"));
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
// parse the message status
TLex8 lex(array[1]);
TUint16 val;
TInt ret=lex.Val(val,EDecimal);
if(ret!=KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
iSmsData.iMessageStatus = val;
//parse the message length
TLex8 lex1(array[3]);
TUint msgLength;
ret=lex1.Val(msgLength,EDecimal);
if(ret!=KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
LOGTEXT2(_L8("CAtSmsStoreReadAll::ParseResponseL\tMessage Length=%d"),msgLength);
TBuf8<KMaxAsciiPduLength> pdu; //Binary Message pdu
SmsAtUtil::ConvertAsciiToBinary(array[4],pdu);
TPtrC8 pduPtr(pdu);
RMobilePhone::TMobileAddress gsmServiceCentre; //messages's SCA
if (msgLength*2 < array[4].Length())
{
// There is an SCA prepended so remove this and store it in iGsmServiceCentre
SmsAtUtil::ReadAndRemoveAddressFromPdu(pduPtr,gsmServiceCentre);
}
iSmsData.iSmsMsg = pduPtr;
iSmsData.iServiceCentre = gsmServiceCentre.iTelNumber;
iSmsData.iMobileScNPI = gsmServiceCentre.iNumberPlan;
iSmsData.iMobileScTON = gsmServiceCentre.iTypeOfNumber;
LOGTEXT2(_L8("CAtSmsStoreReadAll::ParseResponseL\tMessage Status=%d"),
iSmsData.iMessageStatus);
LOGTEXT3(_L8("CAtSmsStoreReadAll::ParseResponseL\tSmsMsg=%S, ServiceCentre=%S"),
&iSmsData.iSmsMsg, &iSmsData.iServiceCentre);
CleanupStack::PopAndDestroy(&array);
}
// ------------------------------------------------
// NotifyModified
// ------------------------------------------------
//
void CMdSNotifier::NotifyModifiedL(const RArray<TItemId>& aObjectIds,
CMdSManipulationEngine* aMEngine)
{
if (aObjectIds.Count() == 0)
{
return;
}
TBool allUrisFetched( EFalse );
RPointerArray<HBufC> allUrisArray;
CleanupResetAndDestroyPushL( allUrisArray );
for( TInt i = iEntries.Count() - 1; i >=0; i-- )
{
TEntry& e = iEntries[i];
if( e.iType & (EObjectNotifyModify | EObjectNotifyModifyWithUri) )
{
// collect matching object IDs
RArray<TItemId> matchingObjectIdArray;
CleanupClosePushL( matchingObjectIdArray );
RPointerArray<HBufC> uriArray;
CleanupResetAndDestroyPushL( uriArray );
const TBool allMatches = iComparator->MatchObjectIdsL( e.Condition(),
aObjectIds, matchingObjectIdArray );
// check is there any matches
if( allMatches || matchingObjectIdArray.Count() > 0 )
{
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TInt err( KErrNone );
if( allMatches )
{
// all matches so send whole object ID array
if( e.iType & EObjectNotifyModifyWithUri )
{
if( !allUrisFetched )
{
aMEngine->GetObjectUrisByIdsL( aObjectIds, allUrisArray );
allUrisFetched = ETrue;
}
TRAP( err, e.TriggerL( EObjectNotifyModifyWithUri,
aObjectIds, allUrisArray ) );
}
else
{
TRAP( err, e.TriggerL( EObjectNotifyModify,
aObjectIds, uriArray ) );
}
}
else
{
if( e.iType & EObjectNotifyModifyWithUri )
{
aMEngine->GetObjectUrisByIdsL( matchingObjectIdArray, uriArray );
TRAP( err, e.TriggerL( EObjectNotifyModifyWithUri,
matchingObjectIdArray, uriArray ) );
}
else
{
TRAP( err, e.TriggerL( EObjectNotifyModify,
matchingObjectIdArray, uriArray ) );
}
}
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
if( allMatches )
{
// all matches so send whole object ID array
if( e.iType & EObjectNotifyModifyWithUri )
{
if( !allUrisFetched )
{
aMEngine->GetObjectUrisByIdsL( aObjectIds, allUrisArray );
allUrisFetched = ETrue;
}
TRAP_IGNORE( e.CacheL( EObjectNotifyModifyWithUri,
aObjectIds, allUrisArray ) );
}
else
{
TRAP_IGNORE( e.CacheL( EObjectNotifyModify,
aObjectIds, uriArray ) );
}
}
else
{
if( e.iType & EObjectNotifyModifyWithUri )
{
aMEngine->GetObjectUrisByIdsL( matchingObjectIdArray, uriArray );
TRAP_IGNORE( e.CacheL( EObjectNotifyModifyWithUri,
matchingObjectIdArray, uriArray ) );
}
else
{
TRAP_IGNORE( e.CacheL( EObjectNotifyModify,
matchingObjectIdArray, uriArray ) );
}
}
}
}
CleanupStack::PopAndDestroy( 2, &matchingObjectIdArray ); // matchingObjectIdArray, uriArray
}
}
CleanupStack::PopAndDestroy( &allUrisArray );
}
void CFdfTest::MndeoDeviceEvent()
{
iManager.Write(_L8("CFdfTest::MndeoDeviceEvent"));
iManager.Write(KNullDesC8());
iManager.Write(_L8("CFdfTest::MndeoDeviceEvent"));
// Apologies for the squashed-up output this gives, but this text is no
// good if it scrolls off the top of the target board's screen.
iManager.Write(_L8("Raw data:"));
iManager.Write(_L8("device ID = %d, event type = %d, error = %d, driver load status = %d, vid = 0x%04x, pid = 0x%04x"),
iDeviceEventInformation.iDeviceId,
iDeviceEventInformation.iEventType,
iDeviceEventInformation.iError,
iDeviceEventInformation.iDriverLoadStatus,
iDeviceEventInformation.iVid,
iDeviceEventInformation.iPid);
iManager.Write(_L8("Interpretation:"));
_LIT8(KAttachment, "Attachment");
_LIT8(KDriverLoad, "Driver load");
_LIT8(KDetachment, "Detachment");
TFixedArray<const TDesC8*, 3> eventType;
eventType[EDeviceAttachment] = &KAttachment();
eventType[EDriverLoad] = &KDriverLoad();
eventType[EDeviceDetachment] = &KDetachment();
_LIT8(KSuccess, "Success");
_LIT8(KPartialSuccess, "Partial success");
_LIT8(KFailure, "Failure");
TFixedArray<const TDesC8*, 3> driverLoadStatus;
driverLoadStatus[EDriverLoadSuccess] = &KSuccess();
driverLoadStatus[EDriverLoadPartialSuccess] = &KPartialSuccess();
driverLoadStatus[EDriverLoadFailure] = &KFailure();
switch ( iDeviceEventInformation.iEventType )
{
case EDeviceAttachment:
{
iManager.Write(_L8("%S | device %d | error %d"),
eventType[iDeviceEventInformation.iEventType],
iDeviceEventInformation.iDeviceId,
iDeviceEventInformation.iError);
}
break;
case EDriverLoad:
iManager.Write(_L8("%S | device %d | %S | error %d"),
eventType[iDeviceEventInformation.iEventType],
iDeviceEventInformation.iDeviceId,
driverLoadStatus[iDeviceEventInformation.iDriverLoadStatus],
iDeviceEventInformation.iError);
break;
case EDeviceDetachment:
iManager.Write(_L8("%S | device %d"),
eventType[iDeviceEventInformation.iEventType],
iDeviceEventInformation.iDeviceId);
break;
default:
iManager.Write(_L8("INVALID iEventType"));
return;
}
if ( iDeviceEventInformation.iEventType == EDeviceAttachment && iDeviceEventInformation.iError == KErrNone )
{
iManager.Write(_L8("VID: 0x%04x, PID: 0x%04x"),
iDeviceEventInformation.iVid,
iDeviceEventInformation.iPid);
RArray<TUint> langIds;
TInt err = iUsbHostStack.GetSupportedLanguages(iDeviceEventInformation.iDeviceId, langIds);
if ( err == KErrNone )
{
const TUint count = langIds.Count();
iManager.Write(_L8("there is/are %d supported language(s)"), count);
for ( TUint ii = 0 ; ii < count ; ++ii )
{
iManager.Write(_L8("using langid %d (index %d)"), langIds[ii], ii);
TName string;
TInt err = iUsbHostStack.GetManufacturerStringDescriptor(iDeviceEventInformation.iDeviceId, langIds[ii], string);
if ( err == KErrNone )
{
TBuf8<256> buf;
buf.Copy(string);
iManager.Write(_L8("manufacturer string descriptor = \"%S\""), &buf);
}
else
{
iManager.Write(_L8("GetManufacturerStringDescriptor returned %d"), err);
}
err = iUsbHostStack.GetProductStringDescriptor(iDeviceEventInformation.iDeviceId, langIds[ii], string);
if ( err == KErrNone )
{
TBuf8<256> buf;
buf.Copy(string);
iManager.Write(_L8("product string descriptor = \"%S\""), &buf);
}
else
{
iManager.Write(_L8("GetProductStringDescriptor returned %d"), err);
}
}
}
else
{
iManager.Write(_L8("GetSupportedLanguages returned %d"), err);
}
langIds.Close();
}
}
TVerdict CTestCalInterimApiDEF064928Step::doTestStepL()
{
CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
iSession = CCalSession::NewL();
CTestCalInterimApiCallbackForAlarms* alarmCallback = CTestCalInterimApiCallbackForAlarms::NewL(this);
CleanupStack::PushL(alarmCallback);
OpenSessionFileL();
iEntryView = CCalEntryView::NewL(*iSession,*alarmCallback);
SetTestStepResult(EFail);
CActiveScheduler::Add(alarmCallback);
CActiveScheduler::Start();
TUint seqNo = 1;
HBufC8* pGUID1= KAlarmExportTestGUID1().AllocLC();
CCalEntry* entry1 = CCalEntry::NewL(CCalEntry::EAppt, pGUID1,
CCalEntry::EMethodAdd, seqNo);
CleanupStack::Pop(pGUID1); // entry takes ownership
CleanupStack::PushL(entry1);
TDateTime entryStart1(2006, EJuly, 6, 15, 0, 0, 0);
TCalTime calStart1;
calStart1.SetTimeLocalL(entryStart1);
TDateTime entryStop1(2006, EJuly, 6, 16, 0, 0, 0);
TCalTime calStop1;
calStop1.SetTimeLocalL(entryStop1);
entry1->SetStartAndEndTimeL(calStart1, calStop1);
TCalRRule* rpt = new (ELeave) TCalRRule(TCalRRule::EDaily);
CleanupStack::PushL(rpt);
rpt->SetInterval(1);
TCalTime startTime;
startTime.SetTimeLocalL(TDateTime(2006, EJuly, 6, 0, 0, 0, 0));
rpt->SetDtStart(startTime);
TCalTime endTime;
endTime.SetTimeLocalL(TDateTime(2006, EJuly, 10, 0, 0, 0, 0));
rpt->SetUntil(endTime);
entry1->SetRRuleL(*rpt); // doesn't take ownership
CleanupStack::PopAndDestroy(rpt);
SaveToAgendaL(entry1, EFalse);
seqNo++;
HBufC8* pGUID2= KAlarmExportTestGUID2().AllocLC();
TDateTime entryTime2(2006, EJuly, 9, 15, 0, 0, 0);
TCalTime calTime2;
calTime2.SetTimeLocalL(entryTime2);
CCalEntry* entry2 = CCalEntry::NewL(CCalEntry::EAppt, pGUID2,
CCalEntry::EMethodAdd, seqNo, calTime2,
CalCommon::EThisOnly);
CleanupStack::Pop(pGUID2); // entry takes ownership
CleanupStack::PushL(entry2);
CreateExceptionDateL(entry2, entry1);
RArray<TCalTime> exDateList1;
CleanupClosePushL(exDateList1);
entry1->GetExceptionDatesL(exDateList1);
TESTL(exDateList1[0].TimeLocalL() == calTime2.TimeLocalL());
CleanupStack::PopAndDestroy();
//build the CCalDataExchange object and Export
RFs fs;
fs.Connect();
CleanupClosePushL(fs);
CCalDataExchange* dataExchange = CCalDataExchange::NewL(*iSession);
CleanupStack::PushL(dataExchange);
RFile outFile;
CleanupClosePushL(outFile);
TInt err = outFile.Replace(fs, KEntryExportFile, EFileWrite);
RFileWriteStream writeStream(outFile);
CleanupClosePushL(writeStream);
INFO_PRINTF1(KExporting);
RPointerArray<CCalEntry> firstEntryArray;
CleanupStack::PushL(TCleanupItem(CloseAndDeleteRPtrArrayEntries, &firstEntryArray));
iEntryView->FetchL(entry1->UidL(), firstEntryArray);
dataExchange->ExportL(KUidVCalendar, writeStream, firstEntryArray);
writeStream.CommitL();
// check that the exception date was stored correctly
CCalEntry *fetchedEntry = firstEntryArray[0];
RArray<TCalTime> exDateList2;
fetchedEntry->GetExceptionDatesL(exDateList2);
CleanupClosePushL(exDateList2);
TESTL(exDateList2[0].TimeLocalL() == calTime2.TimeLocalL());
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy(&writeStream); // writeStream.Close()
CleanupStack::PopAndDestroy(&outFile); // outFile.Close()
//Internalize the entries from the file we just wrote
RFile inFile;
CleanupClosePushL(inFile);
TInt errR = inFile.Open(fs, KEntryExportFile, EFileRead);
RFileReadStream readStream(inFile);
CleanupClosePushL(readStream);
RPointerArray<CCalEntry> secondEntryArray;
CleanupStack::PushL(TCleanupItem(CloseAndDeleteRPtrArrayEntries, &secondEntryArray));
INFO_PRINTF1(KImporting);
dataExchange->ImportL(KUidVCalendar, readStream, secondEntryArray);
CleanupStack::Pop(&secondEntryArray);
CleanupStack::PopAndDestroy(&readStream);
CleanupStack::PopAndDestroy(&inFile);
CleanupStack::PushL(TCleanupItem(CloseAndDeleteRPtrArrayEntries, &secondEntryArray));
// check the imported alarm
TESTL(secondEntryArray.Count() == 1);
CCalEntry* entry = secondEntryArray[0];
RArray<TCalTime> importedExDate;
entry->GetExceptionDatesL(importedExDate);
TESTL(importedExDate.Count() == 1);
TESTL(importedExDate[0].TimeLocalL() == calTime2.TimeLocalL());
CleanupStack::PopAndDestroy(7, scheduler);
SetTestStepResult(EPass);
return TestStepResult();
}
TVerdict CRepositoryCheckStep::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
* Our implementation only gets called if the base class doTestStepPreambleL()
* did not leave. That being the case, the current test result value will be
* EPass.
* Check for the absence and presence of repository settings as specified in
* the config file.
*/
{
SetTestStepResult(EPass);
// See if we just want to wait for a bit. Bit of a strange place
// to put this, but convenient..
TInt pause=0;
TInt bRet = GetIntFromConfig(ConfigSection(), KPause, pause);
if(bRet == 1)
{
pause *= ipauseincrement;
User::After(KDefaultEvictionTimeout + pause);
}
// Get the key for the repository we're interested in. Return if absent.
TInt reposkey=0;
bRet = GetHexFromConfig(ConfigSection(), KRepositoryKey, reposkey );
if(bRet!=1)
{
SetTestStepResult(EFail);
INFO_PRINTF1(HTML_RED);
ERR_PRINTF1(_L("Repository key not specified in .ini file."));
INFO_PRINTF1(HTML_RED_OFF);
return TestStepResult();
}
INFO_PRINTF2(_L("Repository key: 0x%x"), reposkey );
// Get the flag the indicates whether this repository should exist.
// We might be checking for absence.. If this isn't given, assume the
// repository is expected to be present.
TBool repwanted=ETrue;
bRet = GetIntFromConfig(ConfigSection(),KRepositoryPresent, repwanted);
if(bRet != 1) repwanted = ETrue;
INFO_PRINTF2(_L("Repository wanted: %d"), repwanted );
// Create the repository object.
// We have to TRAP here for the case where the repository does not
// exist. This may be wanted or not.
TInt leavecode;
CRepository* repository=NULL;
TRAP(leavecode, repository = CRepository::NewL(TUid::Uid(reposkey)) );
if(repository != NULL) CleanupStack::PushL(repository);
// This is not necessarily an error..
if(leavecode != KErrNone)
INFO_PRINTF2(_L("Leave code: %d"), leavecode );
if(repository == NULL)
INFO_PRINTF1(_L("Repository is NULL"));
else
INFO_PRINTF1(_L("Repository is not NULL"));
if(leavecode == KErrAlreadyExists)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF1(_L("Leavecode is KErrAlreadyExists. Perhaps there's a duplicate key in a keyspace file?"));
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
if(repwanted)
{
if(leavecode == KErrNotFound)
{
SetTestStepResult(EFail);
INFO_PRINTF1(HTML_RED);
ERR_PRINTF1(_L("Required Repository does not exist"));
INFO_PRINTF1(HTML_RED_OFF);
return TestStepResult();
}
else if(leavecode == KErrNone)
{
INFO_PRINTF1(_L("Required Repository exists (correctly)."));
// Drop through.
}
else
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Unexpected leave '%d' creating repository."), leavecode);
INFO_PRINTF1(HTML_RED_OFF);
if(repository != NULL)
CleanupStack::PopAndDestroy(repository);
SetTestStepResult(EFail);
return TestStepResult();
}
}
else // !repwanted
{
if(leavecode == KErrNone)
{
SetTestStepResult(EFail);
INFO_PRINTF1(HTML_RED);
ERR_PRINTF1(_L("Repository exists when it should not."));
INFO_PRINTF1(HTML_RED_OFF);
CleanupStack::PopAndDestroy(repository);
}
else
{
INFO_PRINTF1(_L("Repository is absent (correctly)."));
// The following should not be possible.
if(leavecode != KErrNotFound)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Failure to create repository, but error code is not KErrNotFound! Err=%d"), leavecode);
SetTestStepResult(EFail);
INFO_PRINTF1(HTML_RED_OFF);
}
}
return TestStepResult();
}
// The only way to this point is to have a repository that is wanted.
// Must remember to pop the cleanupstack later!
// Look for the expected total number of settings in this repository.
TInt expectednumsettings;
bRet = GetIntFromConfig(ConfigSection(), KExpectedNumSettings, expectednumsettings );
// If bRet is not set then the user isn't interested in the number of
// settings, which is ok.
if(bRet == 1)
{
RArray<TUint32> foundIds;
TInt r = KErrNone;
leavecode = KErrNone;
INFO_PRINTF2(_L("Looking for number of settings: %d"), expectednumsettings);
TRAP(leavecode, r = repository->FindL(0, 0, foundIds));
if(leavecode != KErrNone)
r = leavecode;
if(r!=KErrNone)
SetTestStepResult(EFail);
INFO_PRINTF2(_L("Number of repository ids: %d"), foundIds.Count());
if(foundIds.Count() != expectednumsettings)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("Failure: Expected number of keys: %d"), expectednumsettings);
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
}
// Look for settings in the repository which should be absent.
TInt nabsent;
bRet = GetIntFromConfig(ConfigSection(), KRepositoryAbsent, nabsent );
// If bRet is not set then the number of absent settings hasn't been
// specified, which is ok.
if(bRet == 1)
{
// Careful if the prefix here changes, we don't want to
// blow this buffer. Also note the 'Delete' a few lines hence.
TBuf<REPCHECKCREATE_ABSBUFLEN> abs(KAbsentPrefix);
TInt len = abs.Length();
for( TInt count=0 ; count < nabsent ; count++ )
{
abs.AppendNum(count); // e.g "Absent27"
TInt absentkey;
// All keys from "Absent0" through "Absent<N-1>" MUST be defined
// in the config file...
bRet = GetHexFromConfig(ConfigSection(), abs, absentkey );
if(bRet != 1)
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF1(_L("Failed to get absent key from config file."));
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
// .. but must not exist in the repository.
TInt vali;
TReal valr;
TBuf<REPCHECKCREATE_MAXSTRINGLEN> vals;
TInt ri = repository->Get( absentkey, vali );
TInt rr = repository->Get( absentkey, valr );
TInt rs = repository->Get( absentkey, vals );
if( (ri==KErrNone) || (rr==KErrNone) || (rs==KErrNone))
{
INFO_PRINTF1(HTML_RED);
ERR_PRINTF2(_L("FAILURE: Repository has key 0x%x which should be absent."), absentkey );
if(!ri) ERR_PRINTF3(_L("Intrc: %d, Value: 0x%x"), ri, vali );
if(!rr) ERR_PRINTF3(_L("Realrc: %d, Value: %f"), rr, valr );
if(!rs) ERR_PRINTF3(_L("Stringrc: %d, Value: %S"), rs, &vals );
INFO_PRINTF1(HTML_RED_OFF);
SetTestStepResult(EFail);
}
abs.Delete(len, REPCHECKCREATE_ABSBUFLEN); // Strip the number..
}
}
// Look for settings in the repository which should be present. Integers
// first..
TInt nints;
bRet = GetIntFromConfig(ConfigSection(), KRepositoryNumInts, nints );
if(bRet == 1)
{
CheckRepositoryIntegerSettings(repository, nints);
}
// Look for settings in the repository which should be present. Now reals.
TInt nreals;
bRet = GetIntFromConfig(ConfigSection(), KRepositoryNumReals, nreals );
if(bRet == 1)
{
CheckRepositoryRealSettings(repository, nreals);
}
// Look for settings in the repository which should be present. Now strings.
TInt nstrings;
bRet = GetIntFromConfig(ConfigSection(), KRepositoryNumStrings, nstrings );
if(bRet == 1)
{
CheckRepositoryStringSettings(repository, nstrings);
}
CleanupStack::PopAndDestroy(repository);
return TestStepResult();
}
void CT_KeypadDriverData::DoCmdTestMultipleKeysL(const TDesC& aSection, const TInt aAsyncErrorIndex)
/**
* Tests multiple key combinations by verifying their scancodes against expected values
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
{
iCombinationStrStore.Reset();
iExpectedStore.Reset();
iActualStore.Reset();
iCombinationKeyCount = 0;
iConsole.ClearScreen();
RArray<TInt> keyStore;
RArray<TPtrC> keyStrStore;
keyStore.Reset();
keyStrStore.Reset();
TIniDataName setStore;
TIniDataName strStore;
TIniDataName fullStore;
TPtrC scanCodeStr;
TInt scanCode;
TInt setIndex=0;
TBool moreSets=ETrue;
while ( moreSets )
{
++setIndex;
keyStore.Reset();
keyStrStore.Reset();
setStore.Format(KSet(), setIndex);
setStore.Append(_L("_"));
TInt index =0;
TBool moreData=ETrue;
while ( moreData )
{
++index;
fullStore = _L("");
strStore.Format(KScanCodeString(), index);
fullStore.Append(setStore);
fullStore.Append(strStore);
moreData=GetStringFromConfig(aSection, fullStore, scanCodeStr);
if ( moreData )
{
fullStore = _L("");
strStore.Format(KScanCode(), index);
fullStore.Append(setStore);
fullStore.Append(strStore);
if (!GetEnumFromConfig(aSection, fullStore, iEnumTableScanCodes, scanCode))
{
ERR_PRINTF2(_L("Invalid scancode value: %d"), scanCode);
SetBlockResult(EFail);
}
else
{
keyStrStore.AppendL(scanCodeStr);
keyStore.AppendL(scanCode);
}
++index;
}
else
{
if (index == 1)
{
moreSets = EFalse;
}
}
}
if (moreSets)
{
TInt keyCount=keyStore.Count();
for ( TInt event=0; event<iEventStore.Count(); ++event )
{
for ( TInt key=0; key<keyCount; ++key )
{
iExpectedStore.AppendL(iEventStore[event]);
iExpectedStore.AppendL(keyStore[key]);
}
}
TIniDataName tempStrArray;
for ( TInt key=0; key<keyCount; ++key )
{
if (tempStrArray == _L(""))
{
tempStrArray.Append(keyStrStore[key]);
}
else
{
tempStrArray.Append(_L(" + "));
tempStrArray.Append(keyStrStore[key]);
}
}
iCombinationStrStore.Append(tempStrArray);
}
}
keyStore.Reset();
keyStore.Close();
keyStrStore.Reset();
keyStrStore.Close();
if (iExpectedStore.Count() > 0)
{//end of setup and start testcase
iConsole.Write(_L("Keyboard layout test.\n"));
iConsole.Write(_L("Press the following keys in the sequence as displayed:\n"));
iConsole.Write(iCombinationStrStore[0]);
iConsole.Write(_L("\n"));
iConsole.Write(_L("and release them in the same sequence."));
iConsole.Read(iKey, iActiveCombination->iStatus);
iActiveCombination->Activate( aAsyncErrorIndex );
IncOutstanding(); // request an event
}
else
{
INFO_PRINTF1(_L("No multiple key sets available"));
}
}
// -----------------------------------------------------------------------------
// CSisxUIStartupFile::ReadStartupItemsL
// Get all startup items from the given resource file.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSisxUIStartupFile::ReadNewStartupItemsL( RArray<TStartupTaskParam>& aStartupItems,
const RPointerArray<HBufC>& aFiles )
{
RResourceFile resource;
CleanupClosePushL( resource );
resource.OpenL( iFileSession, *iNewFile );
TInt index( 0 );
// Read resources
for ( index = 1; resource.OwnsResourceId( index ); index++ )
{
// Create the reader
HBufC8* resBuffer = resource.AllocReadLC( index );
TResourceReader reader;
reader.SetBuffer( resBuffer );
// Read version byte
TInt version = reader.ReadUint8();
// Read actual parameters
TStartupTaskParam item;
item.iFileName.Copy( reader.ReadTPtrC() );
item.iRecoveryPolicy = (TStartupExceptionPolicy) reader.ReadUint16();
aStartupItems.Append( item );
CleanupStack::PopAndDestroy( resBuffer );
}
// Validate the array. Each and every executable to be added to the
// startup list must also be installed by this package.
for ( index = 0; index < aStartupItems.Count(); index++ )
{
// Sanity check
if ( !aStartupItems[index].iFileName.Length() )
{
continue;
}
TBool entryFound( EFalse );
TInt j( 0 );
iTemp = aStartupItems[index].iFileName;
iTemp.Delete( 0, 1 );
iTemp.Fold();
for ( j = 0; j < aFiles.Count(); j++ )
{
if ( aFiles[j]->FindF( iTemp ) >= 0 )
{
entryFound = ETrue;
// Replace the possible ! with correct drive
if ( aStartupItems[index].iFileName[0] == '!' )
{
TBuf<1> temp;
temp.Append( (*aFiles[j])[0] );
aStartupItems[index].iFileName.Replace(0, 1, temp );
}
break;
}
}
if ( !entryFound )
{
aStartupItems.Remove( index );
index--;
}
}
CleanupStack::PopAndDestroy(); // resource
}
// ---------------------------------------------------------------------------
// CNATFWStunSettings::ReadSettingsL
// ---------------------------------------------------------------------------
//
void CNATFWStunSettings::ReadSettingsL( TUint32 aDomainKey,
const CNATFWCenRepHandler& aRepHandler )
{
__NATSETTINGS( "CNATFWStunSettings::ReadSettingsL" )
RArray<TUint32> serverKeys;
CleanupClosePushL( serverKeys );
TBool sharedSecretNotEnabled;
TBool sharedSecretEnabled;
// read sharedsecret enabled
if ( KErrNone != aRepHandler.Read( KUNSAFProtocolsDomainSharedSecretNotSupported |
aDomainKey, sharedSecretNotEnabled ) )
{
sharedSecretEnabled = KNATFWDefaultUseSharedSecret;
}
else
{
sharedSecretEnabled = !sharedSecretNotEnabled;
}
// read server settings
TInt err = aRepHandler.FindServerKeys(
KUNSAFProtocolsSTUNServerTableMask | aDomainKey, serverKeys );
TInt serverCount = serverKeys.Count();
if ( KErrNone == err && serverCount > 0 )
{
for( TInt i( 0 ); i < serverCount; i++ )
{
CNATFWServerSettings* serverSettings = CNATFWServerSettings::NewLC(
KNullDesC8,
KNATFWDefaultSTUNServerPort,
KNullDesC8,
KNullDesC8,
sharedSecretEnabled );
TUint32 key = serverKeys[i] | aDomainKey;
serverSettings->ReadSettingsL( key, aRepHandler );
iServerArray->AppendL( serverSettings );
CleanupStack::Pop( serverSettings );
}
}
else
{
if ( KErrNotFound == err )
{
__NATSETTINGS( "Server settings not found" )
}
else
{
User::Leave( err );
}
}
CleanupStack::PopAndDestroy( &serverKeys );
// read LatestConnectedStunServerAddress and possible port
TInt port = 0;
HBufC8* tempBufPointer = NULL;
tempBufPointer = aRepHandler.ReadL(
KUNSAFProtocolsLatestConnectedSTUNServerAddressMask | aDomainKey );
if ( tempBufPointer )
{
CleanupStack::PushL( tempBufPointer );
HBufC8* addr = TNATFWSettingsParser::ParseAddressLC(
*tempBufPointer, port );
SetLatestConnectedServerAddrL( *addr );
SetLatestConnectedServerPort( port );
CleanupStack::PopAndDestroy( addr );
CleanupStack::PopAndDestroy( tempBufPointer );
}
else
{
SetLatestConnectedServerAddrL( KNullDesC8 );
SetLatestConnectedServerPort( port );
}
// Read LatestConnectedStunServerPort, replaces previous data if found
if ( KErrNone == aRepHandler.Read( KUNSAFProtocolsLatestConnectedSTUNServerPortMask |
aDomainKey, port ) )
{
SetLatestConnectedServerPort( port );
}
// read retransmission timeout
if ( KErrNone != aRepHandler.Read( KUNSAFProtocolsStunRetransmissionTimeoutMask |
aDomainKey, iRto ) )
{
iRto = KNATFWDefaultRtoValue;
}
}
CPolicyPatchInfoList* CPolicyImporter::BuildPolicyPatchInfoListL()
{
LOG_("-> CPolicyImporter::BuildPolicyPatchInfoListL()");
CPolicyPatchInfoList* patchInfoList = new (ELeave) CPolicyPatchInfoList(2);
CleanupStack::PushL(patchInfoList);
HBufC8* subjectName;
// First, append the CA certs to patch list...
for (TInt i = 0; i < iCurrCaCertList->Count(); i++)
{
CPolicyPatchInfo* patchInfo = new (ELeave) CPolicyPatchInfo();
CleanupStack::PushL(patchInfo);
TParse fileNameParser;
fileNameParser.Set(iCurrCaCertList->At(i), NULL, NULL);
patchInfo->iCertFileName.Copy(fileNameParser.NameAndExt());
subjectName = CertSubjectNameL(iCurrCaCertList->At(i));
CleanupStack::PushL(subjectName);
if ( iCurrOtherCaCertList->Count()>1 && iCurrCaCertList->Count()==1 ) //if other than basic CA certificate exists
{
// Set original intermediate CA untrusted. .
HBufC8* certData = iFileUtil.LoadFileDataL(iCurrCaCertList->At(0));
CleanupStack::PushL(certData);
CX509Certificate* tempCert = CX509Certificate::NewLC(*certData);
RArray<TUid> appArray;
CleanupClosePushL(appArray);
const TPtrC8* serialNumber = tempCert->DataElementEncoding(
CX509Certificate::ESerialNumber);
const TPtrC8* issuername = tempCert->DataElementEncoding(
CX509Certificate::EIssuerName);
iPkiService.SetApplicabilityL(
*issuername,
*serialNumber,
appArray);
CleanupStack::PopAndDestroy(3); // appArray, tempcert
//get CA from chain
TFileName rootCAFile=GetCAFromFileListL(*subjectName, iCurrOtherCaCertList);
CleanupStack::PopAndDestroy(subjectName);
subjectName=NULL;
subjectName = CertSubjectNameL(rootCAFile);
CleanupStack::PushL(subjectName);
//Set highest CA as trusted
certData = iFileUtil.LoadFileDataL(rootCAFile);
CleanupStack::PushL(certData);
tempCert = CX509Certificate::NewLC(*certData);
CleanupClosePushL(appArray);
appArray.AppendL(TUid::Uid(KUidVpnManager));
serialNumber = tempCert->DataElementEncoding(
CX509Certificate::ESerialNumber);
issuername = tempCert->DataElementEncoding(
CX509Certificate::EIssuerName);
iPkiService.SetApplicabilityL(
*issuername,
*serialNumber,
appArray);
CleanupStack::PopAndDestroy(3); // appArray, tempcert, certData
}
patchInfo->SetCertSubjectNameL(*subjectName);
patchInfoList->AppendL(patchInfo);
CleanupStack::PopAndDestroy(subjectName);
subjectName=NULL;
CleanupStack::Pop(patchInfo); // patcInfo (now owned by the list)
}
// ... then, append also the user certificates.
for (TInt i = 0; i < iCurrUserCertList->Count(); i++)
{
TInt keySize = 0;
HBufC8* subjectName = CertInfoL(iCurrUserCertList->At(i), keySize);
CleanupStack::PushL(subjectName);
CPolicyPatchInfo* patchInfo = new (ELeave) CPolicyPatchInfo();
CleanupStack::PushL(patchInfo);
TParse fileNameParser;
fileNameParser.Set(iCurrUserCertList->At(i), NULL, NULL);
patchInfo->iCertFileName.Copy(fileNameParser.NameAndExt());
patchInfo->SetCertSubjectNameL(*subjectName);
patchInfo->SetUserCertKeyLen(keySize);
patchInfoList->AppendL(patchInfo);
CleanupStack::Pop(); // patchInfo (now owned by the list)
CleanupStack::PopAndDestroy(); // subjectName
}
CleanupStack::Pop(); // patchInfoList, ownership transferred
LOG_("<- CPolicyImporter::BuildPolicyPatchInfoListL()");
return patchInfoList;
}
void CAccPolAudioUnitBase::CopyL ( const CAccPolAudioUnitBase& aAudioUnitBaseObject )
{
API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::operator() - Enter" );
// Copy base
CAccPolObjectBase::operator=( ( CAccPolObjectBase& )aAudioUnitBaseObject );
//Copy Unit id
iUnitId = aAudioUnitBaseObject.UnitId();
RArray<TInt> sourceIds;
CleanupClosePushL( sourceIds );
//Copy source Ids
aAudioUnitBaseObject.GetSourceIds( sourceIds );
for( TInt i = 0; i < sourceIds.Count(); i++ )
{
iSourceId.AppendL( sourceIds.operator[]( i ) );
}
//Copy previous unit id
iPreUnitId = aAudioUnitBaseObject.PreviousUnitId();
//Copy audio controls.
RPointerArray<CAccPolAudioControlBase> audioControls;
CleanupClosePushL( audioControls );
aAudioUnitBaseObject.GetAudioControlsL( audioControls );
for( TInt j = 0; j < audioControls.Count(); j++ )
{
TUint8 objectType;
objectType = audioControls.operator[]( j )->ObjectType();
switch( objectType )
{
case EAccPolAudioVolumeControlObject:
{
CAccPolVolumeControl *volumeControl =
CAccPolVolumeControl::NewL();
CleanupStack::PushL( volumeControl );
*volumeControl
= *( CAccPolVolumeControl* )audioControls.operator[]( j );
iAudioControls.AppendL( volumeControl );
CleanupStack::Pop();
}
break;
case EAccPolAudioMuteControlObject:
{
CAccPolMuteControl *muteControl = CAccPolMuteControl::NewL();
CleanupStack::PushL( muteControl );
*muteControl
= *( CAccPolMuteControl* )audioControls.operator[]( j );
iAudioControls.AppendL( muteControl );
CleanupStack::Pop();
}
break;
case EAccPolAudioInputControlObject:
{
CAccPolInputControl *inputControl = CAccPolInputControl::NewL();
CleanupStack::PushL( inputControl );
*inputControl
= *( CAccPolInputControl* )audioControls.operator[]( j );
iAudioControls.AppendL( inputControl );
CleanupStack::Pop();
}
break;
default:
{
User::Leave( KErrNotSupported );
}
break;
}
}
CleanupStack::PopAndDestroy (); //audioControls...dont use ResetAndDestroy on this!
CleanupStack::PopAndDestroy (); //sourceIds
API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::operator() - Return" );
}
void CMMAAudioRecorderFactory::MediaIdsL(RArray<TUid>& aMediaIds)
{
User::LeaveIfError(aMediaIds.Append(KUidMediaTypeAudio));
}
void QMLBackendTriggerChangeAO::RunL()
{
switch (iStatus.Int()) {
case KErrNone :
#if 0
//implementation takes the updation, deletion into consideration
//from the UI, which is'nt possible with the current UI for LBT.
//The same should be considered once made availbale as part of the UI
//check for Multiple trigger change events
if (iTriggerChangeEvent.iEventType == ELbtTriggerChangeEventMultiple) {
CMonitorTriggerInfo* triggerInfo1 = NULL;
CMonitorTriggerInfo* triggerInfo2 = NULL;
CMonitorTriggerInfo* triggerInfo3 = NULL;
TInt i = 0, count = 0;
RPointerArray < CLbtTriggerInfo > trigInfoList;
CLbtTriggerEntry* entry = NULL;
//retrieve the list of triggers created by the client
iLbt.GetTriggersL(trigInfoList);
CleanupClosePushL(trigInfoList);
count = trigInfoList.Count();
//get the header of the linked list holding the information
//of the trigger
triggerInfo1 = iTriggerMonitorInfo->getMonitorTriggerInfo();
while (triggerInfo1) {
for (i = 0; i < count; i++) {
//get the trigger entryinfo
entry = trigInfoList[i]->TriggerEntry();
//if the triggerinfo retrieved matches the trigInfoList
//id break
if (triggerInfo1->iTriggerID == entry->Id())
break;
}
triggerInfo2 = triggerInfo1->next;
if (i == count) //if the triggerinfo1->triggerid not found
//in the trigger list of the LBT server,
//remove the triggerinfo from the linked list
{
iTriggerMonitorInfo->removeMonitorTriggerInfo(
triggerInfo1->iTriggerID);
} else {
//if triggerinfo1->triggerid is found in the trigger list,
//and if it is an entry trigger, search for the corresponding
//exit trigger in the linked list
if (triggerInfo1->iType == EntryTrigger)
triggerInfo3 = iTriggerMonitorInfo->getMonitorTriggerInfo(
triggerInfo1->iParent , ExitTrigger);
//if triggerinfo1->triggerid is found in the trigger list,
//and if it is an entry trigger, search for the corresponding
//entry trigger in the linked list
else if (triggerInfo1->iType == ExitTrigger)
triggerInfo3 = iTriggerMonitorInfo->getMonitorTriggerInfo(
triggerInfo1->iParent, EntryTrigger);
//callback called for the notification change event of the trigger
if (triggerInfo3) {
(triggerInfo1->iParent)->handleTriggerChangeEvent(iTriggerChangeEvent.iEventType, trigInfoList[i],
triggerInfo3->iTriggerID);
} else {
(triggerInfo1->iParent)->handleTriggerChangeEvent(iTriggerChangeEvent.iEventType, trigInfoList[i],
NULL);
}
}
triggerInfo3 = NULL;
triggerInfo1 = triggerInfo2;
}
CleanupStack::Pop(1);
//cloae the trigInfoList, holding the list of trigger
//info
trigInfoList.Close();
}
//check for trigger delete event
else if (iTriggerChangeEvent.iEventType == ELbtTriggerChangeEventDeleted) {
//delete the entry from the linked list,corresponding to the
//iTriggerChangeEvent.iTriggerId
iTriggerMonitorInfo->removeMonitorTriggerInfo(
iTriggerChangeEvent.iTriggerId);
}
//check for trigger updation event
else if (iTriggerChangeEvent.iEventType == ELbtTriggerChangeEventUpdated) {
CLbtTriggerInfo *info = NULL;
//get the triggerinfo from the linked list corresponding
//to the iTriggerChangeEvent.iTriggerId
CMonitorTriggerInfo* triggerInfo1 = iTriggerMonitorInfo->getMonitorTriggerInfo(
iTriggerChangeEvent.iTriggerId);
if (!triggerInfo1)
break;
//get the triggerinfo of trigger with id - iTriggerChangeEvent.iTriggerId
//from the LBT server
info = iLbt.GetTriggerLC(iTriggerChangeEvent.iTriggerId);
if (info == NULL)
break;
//change in one-trigger,must update the corresponding entry/exit
//trigger
if (triggerInfo1) {
CMonitorTriggerInfo* triggerInfo2 = NULL;
//if the trigger updated is EntryTrigger, get the information
//of the corresponding ExitTrigger if any,from the
//linked list
if (triggerInfo1->iType == EntryTrigger)
triggerInfo2 = iTriggerMonitorInfo->getMonitorTriggerInfo(
triggerInfo1->iParent, ExitTrigger);
//if the trigger updated is ExitTrigger, get the information
//of the corresponding EntryTrigger if any,fro mthe
//linked list
else if (triggerInfo1->iType == ExitTrigger)
triggerInfo2 = iTriggerMonitorInfo->getMonitorTriggerInfo(
triggerInfo1->iParent, EntryTrigger);
//callback called for the notification change event for the trigger
if (triggerInfo2) {
(triggerInfo1->iParent)->handleTriggerChangeEvent(iTriggerChangeEvent.iEventType, info,
triggerInfo2->iTriggerID);
} else {
(triggerInfo1->iParent)->handleTriggerChangeEvent(iTriggerChangeEvent.iEventType, info,
NULL);
}
}
//pop and destroy the triggerinfo retrived from GetTriggerLC()
CleanupStack::PopAndDestroy(info);
}
#endif
if (iTriggerChangeEvent.iEventType == ELbtTriggerChangeEventMultiple) {
CMonitorTriggerInfo* triggerInfo1 = NULL;
CMonitorTriggerInfo* triggerInfo2 = NULL;
TInt i = 0, count = 0;
RArray < TLbtTriggerId > triggerIdList;
//retrieve the list of trigger IDs created by the client
TRAPD(ret, iLbt.ListTriggerIdsL(triggerIdList));
if (ret != KErrNone) {
break;
}
CleanupClosePushL(triggerIdList);
count = triggerIdList.Count();
//get the header of the linked list holding the information
//of the trigger
triggerInfo1 = iTriggerMonitorInfo->getMonitorTriggerInfo();
while (triggerInfo1) {
for (i = 0; i < count; i++) {
//if the triggerinfo retrieved matches the triggerIdList
//id break
if (triggerInfo1->iTriggerID == triggerIdList[i])
break;
}
triggerInfo2 = triggerInfo1->next;
if (i == count) //if the triggerinfo1->triggerid not found
//in the trigger list of the LBT server,
//remove the triggerinfo from the linked list
{
iTriggerMonitorInfo->removeMonitorTriggerInfo(
triggerInfo1->iTriggerID);
}
triggerInfo1 = triggerInfo2;
}
CleanupStack::Pop(1);
//close the trigInfoList, holding the list of trigger
//info
triggerIdList.Close();
}
//check for trigger delete event
else if (iTriggerChangeEvent.iEventType == ELbtTriggerChangeEventDeleted) {
//delete the entry from the linked list,corresponding to the
//iTriggerChangeEvent.iTriggerId
iTriggerMonitorInfo->removeMonitorTriggerInfo(
iTriggerChangeEvent.iTriggerId);
}
break;
default :
break;
}
//request for the notification of any notification change events
NotifyChangeEvent();
}
// ****************************************************************************
//
// Function Name: RSingleSelection::Render( )
//
// Description: Draws the selection rect and handles
//
// Returns: Nothing
//
// Exceptions: Memory
//
// ****************************************************************************
//
void RSingleSelection::Render( RDrawingSurface& drawingSurface, const R2dTransform& transform, const RIntRect& rcRender, BOOLEAN fRenderIfLocked ) const
{
// Get the component attributes
const RComponentAttributes& componentAttributes = m_pSelectedObject->GetComponentAttributes( );
BOOLEAN fIsLocked = componentAttributes.IsLocked( );
if( fRenderIfLocked || !fIsLocked )
{
// Set surface attributes
drawingSurface.SetPenWidth( kSelectionOutlineWidth );
drawingSurface.SetPenStyle( kSolidPen );
RRealRect resizeHandleRect;
// Draw the resize handles
if( componentAttributes.IsResizable( FALSE ) )
{
RArray<RRealRect> rectList;
RRealSize scaleFactor( kDummyScale, kDummyScale );
scaleFactor = m_pSelectedObject->ApplyResizeConstraint( scaleFactor );
GetResizeSelectionHandle( resizeHandleRect, transform, kTopLeftResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kTopRightResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kBottomRightResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kBottomLeftResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
if ( !AreFloatsEqual( scaleFactor.m_dy, kConstrainedScale ) )
{
GetResizeSelectionHandle( resizeHandleRect, transform, kBottomResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kTopResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
}
if ( !AreFloatsEqual( scaleFactor.m_dx, kConstrainedScale ) )
{
GetResizeSelectionHandle( resizeHandleRect, transform, kRightResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kLeftResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
}
RArray<RRealRect>::YIterator iterator = rectList.Start( );
RArray<RRealRect>::YIterator iteratorEnd = rectList.End( );
if( fIsLocked )
{
while ( iterator != iteratorEnd )
drawingSurface.FrameRectangle( *iterator++ );
}
else
{
while ( iterator != iteratorEnd )
drawingSurface.FillRectangle( *iterator++ );
}
}
// Draw the rotate line and handle
if( componentAttributes.IsRotatable( ) )
DrawRotateHandle( drawingSurface, transform, rcRender );
// Draw the selection frame
m_pSelectedObject->DrawSelectionFrame( drawingSurface, transform );
}
}
// -----------------------------------------------------------------------------
// CNSmlDsProvisioningAdapter::SaveL
// -----------------------------------------------------------------------------
void CNSmlDsProvisioningAdapter::SaveL(TInt aItem)
{
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): begin");
TPckgBuf<TUint32> uid;
RSyncMLDataSyncProfile profile;
TBool ret = EFalse;
if(iProfiles[aItem]->iServerId != NULL)
{
RSyncMLDataSyncProfile ProfileToSearch;
RArray<TSmlProfileId> arr;
iSession.ListProfilesL( arr, ESmlDataSync );
TInt ProfileId = KErrNotFound;
CleanupClosePushL(arr);
for ( TInt index = 0; index < arr.Count(); index++ )
{
TRAPD( error, ProfileToSearch.OpenL(iSession, arr[index], ESmlOpenRead ) );
if ( error == KErrNone )
{
if ( ( iProfiles[aItem]->iServerId->Des()).Compare(ProfileToSearch.ServerId() ) == 0 )
{
ret = ETrue;
ProfileId = (TInt)arr[index];
ProfileToSearch.Close();
break;
}
}
ProfileToSearch.Close();
}
CleanupStack::PopAndDestroy( &arr );
if( ret )
{
profile.OpenL(iSession, ProfileId , ESmlOpenReadWrite );
}
else
{
profile.CreateL( iSession );
}
CleanupClosePushL( profile );
}
else
{
profile.CreateL( iSession );
CleanupClosePushL( profile );
}
// ui needs this to be set 0
profile.SetCreatorId(0);//iProfiles[aItem]->iProfile.SetCreatorId(0);
profile.SetSanUserInteractionL( iProfiles[aItem]->iServerAlertedAction );
if ( iProfiles[aItem]->iDisplayName )
{
profile.SetDisplayNameL( iProfiles[aItem]->iDisplayName->Des() );
}
if ( iProfiles[aItem]->iServerId )
{
profile.SetServerIdL( iProfiles[aItem]->iServerId->Des() );
}
if ( iProfiles[aItem]->iUsername )
{
profile.SetUserNameL( iProfiles[aItem]->iUsername->Des() );
}
if ( iProfiles[aItem]->iPassword )
{
profile.SetPasswordL( iProfiles[aItem]->iPassword->Des() );
}
// creates profile -> must be done before opening the connection
profile.UpdateL();
RSyncMLConnection connection;
connection.OpenL( profile, KUidNSmlMediumTypeInternet.iUid );
CleanupClosePushL( connection );
if ( (iProfiles[aItem]->iVisitParameter
&& iProfiles[aItem]->iVisitParameter->Data().Length() == uid.MaxLength() )
|| iToNapIDInternetIndicator)
{
TUint apId = 0;
TInt ERROR = KErrNone;
TInt err1 = KErrNone;
if (iToNapIDInternetIndicator)
{
//Get Access Point from DB or SNAP
TRAP(err1, apId = WPAdapterUtil::GetAPIDL());
}
else
{
uid.Copy(iProfiles[aItem]->iVisitParameter->Data() );
RCmManagerExt cmmanagerExt;
cmmanagerExt.OpenL();
CleanupClosePushL(cmmanagerExt);
RCmConnectionMethodExt cm;
cm = cmmanagerExt.ConnectionMethodL( uid());
CleanupClosePushL( cm );
TRAP( ERROR, apId = cm.GetIntAttributeL(CMManager::ECmIapId) );
CleanupStack::PopAndDestroy(2); //cmmanager,cm
}
//Get default access point in failure of getting AP
if (ERROR != KErrNone || err1 != KErrNone)
{
apId = GetDefaultIAPL();
}
HBufC8* iapBuf = HBufC8::NewLC( 8 );
TPtr8 ptrBuf = iapBuf->Des();
ptrBuf.Num( apId );
connection.SetPropertyL( KNSmlIAPId, *iapBuf );
CleanupStack::PopAndDestroy(); //iapBuf
}
if( iProfiles[aItem]->iHostAddress )
{
// see if address contains also port
TBool portFound = EFalse;
TInt startPos(0);
if(iProfiles[aItem]->iHostAddress->Find(KNSmlDsProvisioningHTTP)==0)
{
startPos=KNSmlDsProvisioningHTTP().Length();
}
else if(iProfiles[aItem]->iHostAddress->Find(KNSmlDsProvisioningHTTPS)==0)
{
startPos=KNSmlDsProvisioningHTTPS().Length();
}
TPtrC uriPtr = iProfiles[aItem]->iHostAddress->Mid(startPos);
if(uriPtr.Locate(KNSmlDMColon)!=KErrNotFound)
{
portFound = ETrue;
}
if( portFound == EFalse )
{
HBufC *uri = 0;
// port not found from URI -> see if it is given separately
if( iProfiles[aItem]->iPort )
{
// parse address and port into URI
if( CombineURILC( iProfiles[aItem]->iHostAddress->Des(),
iProfiles[aItem]->iPort->Des(), uri ) == KErrNone )
{
if(iProfiles[aItem]->iHostAddress)
{
delete iProfiles[aItem]->iHostAddress;
iProfiles[aItem]->iHostAddress = NULL;
}
iProfiles[aItem]->iHostAddress = uri->Des().AllocL();
}
CleanupStack::PopAndDestroy(); // uri
}
else
{
// use default port
if( CombineURILC( iProfiles[aItem]->iHostAddress->Des(),
KNSmlDsDefaultPort(), uri ) == KErrNone )
{
if(iProfiles[aItem]->iHostAddress)
{
delete iProfiles[aItem]->iHostAddress;
iProfiles[aItem]->iHostAddress = NULL;
}
iProfiles[aItem]->iHostAddress = uri->Des().AllocL();
}
CleanupStack::PopAndDestroy(); // uri
}
}
connection.SetServerURIL( ConvertTo8LC( iProfiles[aItem]->iHostAddress->Des() ) );
CleanupStack::PopAndDestroy(); // ConvertTo8LC
}
// set authtype, HTTPUserName, HTTPPassword
if( iProfiles[aItem]->iHTTPUserName ||
iProfiles[aItem]->iHTTPPassword )
{
connection.SetPropertyL( KNSmlHTTPAuth, KNSmlTrueVal );
if( iProfiles[aItem]->iHTTPUserName )
{
connection.SetPropertyL( KNSmlHTTPUsername, iProfiles[aItem]->iHTTPUserName->Des() );
}
if( iProfiles[aItem]->iHTTPPassword )
{
connection.SetPropertyL( KNSmlHTTPPassword, iProfiles[aItem]->iHTTPPassword->Des() );
}
}
else
{
connection.SetPropertyL( KNSmlHTTPAuth, KNSmlFalseVal );
}
connection.UpdateL();
CleanupStack::PopAndDestroy(); // connection
if(iProfiles[aItem]->iProtocolVersion == ESmlVersion1_1_2 ||
iProfiles[aItem]->iProtocolVersion == ESmlVersion1_2 )
{
profile.SetProtocolVersionL(iProfiles[aItem]->iProtocolVersion);
}
TInt iDataProvElementCount = iProfiles[aItem]->iDataProvElement.Count();
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: before Start");
for ( TInt i = 0; i < iDataProvElementCount; i++ )
{
_DBG_FILE(
"CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: In");
RSyncMLDataProvider dataProvider;
TRAPD(error, dataProvider.OpenL(iSession,
iProfiles[aItem]->iDataProvElement[i]->iUid));
if (!error)
{
CleanupClosePushL(dataProvider);
if (ret)
{
RArray<TSmlTaskId> providers;
profile.ListTasksL(providers);
TInt dataprovcount = providers.Count();
for (TInt i = 0; i < dataprovcount; i++)
{
TSmlTaskId taskID = providers[i];
RSyncMLTask task;
task.OpenL(profile, taskID);
CleanupClosePushL(task);
if (dataProvider.Identifier() == task.DataProvider())
{
profile.DeleteTaskL(taskID);
CleanupStack::PopAndDestroy();
break;
}
CleanupStack::PopAndDestroy();
}
providers.Reset();
providers.Close();
}
HBufC* localDB = dataProvider.DefaultDataStoreName().AllocLC();
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): DB value");
DBG_ARGS(
iProfiles[aItem]->iDataProvElement[i]->iRemoteDBUri->Des().Ptr());
RSyncMLTask task;
task.CreateL(
profile,
iProfiles[aItem]->iDataProvElement[i]->iUid,
iProfiles[aItem]->iDataProvElement[i]->iRemoteDBUri->Des(),
localDB->Des());
CleanupClosePushL(task);
TRAPD(err, task.UpdateL());
if (err != KErrAlreadyExists && err != KErrNone)
{
User::Leave(err);
}
CleanupStack::PopAndDestroy(3); // task, localDB, dataProvider
}
}
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: after End");
profile.UpdateL();
iProfiles[aItem]->iProfileId = profile.Identifier();
CleanupStack::PopAndDestroy( &profile );
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): end");
}
void CEmTubeSearchView::HandleCommandL( TInt aCommand )
{
TInt which = CurrentToActual();
switch(aCommand)
{
case EMTVSendViaBluetoothCommand:
{
CSendUi* sendUi = CSendUi::NewLC();
CMessageData* mdata = CMessageData::NewLC();
mdata->AppendAttachmentL( iAppUi->SearchEntries()[ which ]->SavedFileName() );
sendUi->CreateAndSendMessageL( KSenduiMtmBtUid, mdata );
CleanupStack::PopAndDestroy( mdata );
CleanupStack::PopAndDestroy( sendUi );
}
break;
case EMTVSearchViewDownloadCommand:
{
// iAppUi->CancelDownloadImageL();
iContainer->DownloadL( );
}
break;
case EMTVAddToPlaylistCommand:
{
RArray<TInt> indices;
CleanupClosePushL( indices );
CAknSinglePopupMenuStyleListBox* plist = new(ELeave) CAknSinglePopupMenuStyleListBox;
CleanupStack::PushL(plist);
CAknPopupList* popupList = CAknPopupList::NewL( plist, R_AVKON_SOFTKEYS_MENU_LIST, AknPopupLayouts::EPopupSNotePopupWindow);
CleanupStack::PushL(popupList);
plist->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);
plist->CreateScrollBarFrameL(ETrue);
plist->ScrollBarFrame()->SetScrollBarVisibilityL(
CEikScrollBarFrame::EOff,
CEikScrollBarFrame::EAuto);
MDesCArray* itemList = plist->Model()->ItemTextArray();
CDesCArray* items = (CDesCArray*) itemList;
popupList->SetTitleL( KNullDesC() );
HBufC* txt = StringLoader::LoadLC( R_PLAYLIST_CREATE_NEW_TXT );
indices.Append( -1 );
items->AppendL( *txt );
CleanupStack::PopAndDestroy( txt );
TInt count = iManager->PlaylistsCount();
for(TInt i=0;i<count;i++)
{
CEmTubePlaylist* pl = iManager->Playlist( i );
if( pl->Editable() )
{
indices.Append( i );
items->AppendL( pl->Name() );
}
}
TInt popupOk = popupList->ExecuteLD();
if(popupOk)
{
TInt idx = indices[ plist->CurrentItemIndex() ];
if( idx == -1 )
{
TBuf<64> name;
CAknTextQueryDialog* dlg = new(ELeave)CAknTextQueryDialog( name, CAknQueryDialog::ENoTone );
dlg->SetPredictiveTextInputPermitted( ETrue );
TInt ret = dlg->ExecuteLD( R_EMTV_ADD_PLAYLIST_DIALOG );
if( ret )
{
iManager->AddPlaylistL( name, CEmTubePlaylist::EPlaylistUserDefined );
idx = iManager->PlaylistsCount() - 1;
}
}
if( idx >= 0 )
{
CEmTubePlaylist* pl = iManager->Playlist( idx );
CVideoEntry* e = iAppUi->SearchEntries()[ which ];
if( iAppUi->SearchDisplayMode() == CEmTubeAppUi::ESearchDisplaySearchEntries ||
iAppUi->SearchDisplayMode() == CEmTubeAppUi::ESearchDisplayFavEntries )
pl->AddEntryL( e->Url(), e->MediaTitle(), CEmTubePlaylistEntry::EPlaylistEntryRemote );
else
pl->AddEntryL( e->SavedFileName(), e->MediaTitle(), CEmTubePlaylistEntry::EPlaylistEntryLocal );
}
}
CleanupStack::Pop( popupList );
CleanupStack::PopAndDestroy( plist );
CleanupStack::PopAndDestroy( &indices );
}
break;
case EMTVSearchViewAddToFCommand:
{
iContainer->AddCurrentItemToFavsL();
}
break;
case EMTVSearchViewRemoveFromFCommand:
{
iContainer->RemoveCurrentItemFromFavsL();
}
break;
case EMTVSearchCommand:
{
if( iAppUi->SearchDialogL() )
{
// TODO: when displaying featured (for example), new search (from menu) - change navi pane text
// if(no tabs, one plugin)
// iContainer->SetNaviPaneTextL();
StartProgressBarL( EFalse );
}
}
break;
case EMTVSearchViewPlayCommand:
{
if( which != KErrNotFound )
{
iAppUi->CancelDownloadImageL();
if( iAppUi->SearchDisplayMode() == CEmTubeAppUi::ESearchDisplaySavedEntries )
iAppUi->OpenFileL( iAppUi->SearchEntries()[ which ]->SavedFileName(), iAppUi->SearchEntries()[ which ]->MediaTitle() );
else
iAppUi->OpenFileL( iAppUi->SearchEntries()[ which ] );
}
}
break;
case EMTVDeleteClipCommand:
{
iContainer->DeleteSavedClipL();
}
break;
case EMTVRenameClipCommand:
{
iContainer->RenameSavedClipL();
}
break;
case EMTVShowRelatedCommand:
{
if( which != KErrNotFound )
{
iAppUi->CancelDownloadImageL();
CVideoEntry* e = iAppUi->SearchEntries()[ which ];
iAppUi->SearchString().Copy( e->RelatedUrl() );
StartProgressBarL( EFalse );
iAppUi->ClearSearchResults();
iAppUi->SearchL( ERelatedClips, ERelevance, EPeriodIrrelevant );
}
}
break;
case EMTVShowUserCommand:
{
if( which != KErrNotFound )
{
iAppUi->CancelDownloadImageL();
CVideoEntry* e = iAppUi->SearchEntries()[ which ];
iAppUi->SearchString().Copy( e->AuthorVideosUrl() );
StartProgressBarL( EFalse );
iAppUi->ClearSearchResults();
iAppUi->SearchL( EUserClips, EUpdated, EPeriodIrrelevant );
}
}
break;
case EMTVSearchViewDetailsCommand:
{
iContainer->ShowToolbar( EFalse );
CEmTubeDetailsDialog::RunDialogL( iAppUi->SearchEntries()[ which ] );
iContainer->ShowToolbar( ETrue );
}
break;
case EMTVSearchViewBackCommand:
{
iContainer->ClearToolbar();
iAppUi->CancelDownloadImageL();
iAppUi->HandleCommandL( EMTVActivateMainViewCommand );
}
break;
case EMTVProgressDialogCancel:
{
iAppUi->CancelDownloadImageL();
if( iAppUi->SearchEntries().Count() )
iContainer->CancelProgressL();
else
iAppUi->HandleCommandL( EMTVActivateMainViewCommand );
}
break;
default:
{
iAppUi->HandleCommandL(aCommand);
}
break;
}
}
// ----------------------------------------------------------------------------
// Message dispatcher
// ----------------------------------------------------------------------------
//
void CMPXPlaybackSession::DispatchMessageL( const RMessage2& aMessage, TInt& aMsgHandleResult )
{
aMsgHandleResult = KErrNone;
//
// All methods apart from the player creation methods, require a player
//
TInt op=aMessage.Function();
if (op != EPbsSetMode)
{
CheckPlayerL();
}
MPX_DEBUG3("-->CMPXPlaybackSession::DispatchMessageL %d, this 0x%08x",
op, this);
switch(op)
{
case EPbsSetMode:
{
SetModeL(aMessage);
break;
}
case EPbsGetClients:
{
RArray<TProcessId> procArray;
::CopyArrayL<TProcessId>(
iPlayer->ClientList()->ClientProcessList(),
procArray );
TProcessId lastPid = static_cast<CMPXPlaybackServer*>(
const_cast<CServer2*>(Server()))->LastActiveProcessId();
TInt index( procArray.Find( lastPid ));
if ( KErrNotFound != index && index )
{
procArray.Remove( index );
procArray.Insert( lastPid, 0 );
}
::CreateBufferL<TProcessId>(
procArray.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
procArray.Close();
break;
}
case EPbsGetSyncBuffer:
{
aMessage.WriteL(0,iSyncBuffer->Ptr(0));
delete iSyncBuffer;
iSyncBuffer = NULL;
break;
}
case EPbsGetAsyncBuffer:
{
//In case of other application leaving, causing us to leave
//we could have a task that does not get removed from the top of the queue
//but the data for that task has been deleted.
//When the task runs again, there will be no data causing a panic - leave if this occurs
User::LeaveIfNull(iAsyncBuffer);
aMessage.WriteL(0,iAsyncBuffer->Ptr(0));
delete iAsyncBuffer;
iAsyncBuffer = NULL;
break;
}
case EPbsInitFromCollection:
{
MPXUser::CreateBufferL(aMessage, 0, iSyncBuffer);
CMPXCollectionPlaylist* p = NULL;
::NewFromBufferL(*iSyncBuffer, p);
delete iSyncBuffer;
iSyncBuffer = NULL;
CleanupStack::PushL(p);
iPlayer->InitL(*p,aMessage.Int1());
CleanupStack::PopAndDestroy(p);
}
break;
case EPbsInitFromUri:
{
CBufBase* buf0(NULL);
MPXUser::CreateBufferL(aMessage,0,buf0);
CleanupStack::PushL(buf0);
// Type parameter is optional
if ( aMessage.GetDesLength( 1 ) > 0 )
{
CBufBase* buf1(NULL);
MPXUser::CreateBufferL(aMessage,1,buf1);
CleanupStack::PushL(buf1);
iPlayer->InitL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0));
CleanupStack::PopAndDestroy(buf1);
}
else
{
MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);
iPlayer->InitL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8 );
}
CleanupStack::PopAndDestroy(buf0);
}
break;
case EPbsInitFromFile:
{
InitFromFileL(aMessage);
break;
}
case EPbsInitStreamingFromUri:
{
CBufBase* buf0(NULL);
MPXUser::CreateBufferL(aMessage,0,buf0);
CleanupStack::PushL(buf0);
// Type parameter is optional
if ( aMessage.GetDesLength( 1 ) > 0 )
{
CBufBase* buf1(NULL);
MPXUser::CreateBufferL(aMessage,1,buf1);
CleanupStack::PushL(buf1);
iPlayer->InitStreamingL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0), aMessage.Int2());
CleanupStack::PopAndDestroy(buf1);
}
else
{
MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);
iPlayer->InitStreamingL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8, aMessage.Int2() );
}
CleanupStack::PopAndDestroy(buf0);
break;
}
case EPbsInitStreamingFromFile:
{
RFile file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->InitStreamingL(file, aMessage.Int2());
file.Close();
break;
}
case EPbsCancelRequest:
{
CancelRequests();
break;
}
case EPbsGetState:
{
aMsgHandleResult = iPlayer->State();
break;
}
case EPbsSetProperty:
{
iPlayer->SetL(static_cast<TMPXPlaybackProperty>(aMessage.Int0()),
aMessage.Int1());
break;
}
case EPbsGetProperty:
{
SetAsync(aMessage);
iPlayer->PropertyL(
static_cast<TMPXPlaybackProperty>(aMessage.Int0()),*this);
break;
}
case EPbsGetPlayerTypes:
{
RArray<TMPXPlaybackPlayerType> pluginTypes;
CleanupClosePushL(pluginTypes);
RArray<TInt> types;
CleanupClosePushL(types);
iPlayer->PluginHandler()->GetPluginTypes(types);
for (TInt i=0; i< types.Count(); ++i)
{
pluginTypes.AppendL(
static_cast<TMPXPlaybackPlayerType>(types[i]));
}
CleanupStack::PopAndDestroy(&types);
::CreateBufferL<TMPXPlaybackPlayerType>(
pluginTypes.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(&pluginTypes);
break;
}
case EPbsGetPlayerTypeDisplayName:
{
const TDesC& playerName = iPlayer->PluginHandler()->PlayerName(
static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));
aMsgHandleResult = 0;
if (playerName.Length()>0)
{
MPXUser::CreateBufferL(playerName, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetAllPlayersUids:
{
RArray<TUid> uids;
CleanupClosePushL(uids);
iPlayer->PluginHandler()->GetPluginUids(uids);
::CreateBufferL<TUid>(
uids.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(&uids);
break;
}
case EPbsGetPlayersUidsForType:
{
aMsgHandleResult = CreatePlayerUidsBufferL(aMessage);
break;
}
case EPbsGetSubPlayerNamesByUid:
{
SetAsync(aMessage);
iPlayer->SubPlayerNamesL(TUid::Uid(aMessage.Int0()),*this);
break;
}
case EPbsSelectPlayerByType:
{
iPlayer->PluginHandler()->SelectPlayersL(
static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));
break;
}
case EPbsSelectPlayerByUid:
{
iPlayer->PluginHandler()->SelectPlayerL(TUid::Uid(aMessage.Int0()));
break;
}
case EPbsSelectSubPlayer:
{
iPlayer->PluginHandler()->SelectSubPlayerL(
TUid::Uid(aMessage.Int0()),aMessage.Int1());
break;
}
case EPbsClearPlayerSelection:
{
iPlayer->PluginHandler()->ClearSelectPlayersL();
break;
}
case EPbsGetSelection:
{
GetSelectionL(aMessage);
break;
}
case EPbsPlayerFound:
{
aMsgHandleResult = iPlayer->PluginHandler()->PlayerFound();
break;
}
case EPbsGetPlayerType:
{
aMsgHandleResult = iPlayer->PluginHandler()->PluginType();
break;
}
case EPbsGetTypeName:
{
MPXUser::CreateBufferL(iPlayer->PluginHandler()->PlayerName(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
break;
}
case EPbsGetSubPlayerIndex:
{
aMsgHandleResult = iPlayer->PluginHandler()->SubPlayer();
break;
}
case EPbsGetPlayerUid:
{
TPckgC<TInt> uidPkg((iPlayer->PluginHandler()->PluginUid()).iUid);
aMessage.Write(0,uidPkg);
break;
}
case EPbsGetCollectionPlaylist:
{
aMsgHandleResult = 0;
if (iPlayer->Playlist())
{
::CreateBufferL<CMPXCollectionPlaylist>(*(iPlayer->Playlist()),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetFile:
{
const RFile& file = iPlayer->File();
if (file.SubSessionHandle())
{
aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed
}
else
{
TPckgC<TInt> handle(KErrNotFound);
aMessage.Write(0, handle);
}
break;
}
case EPbsGetUri:
{
aMsgHandleResult=0;
if (iPlayer->Uri().Length()>0)
{
MPXUser::CreateBufferL(iPlayer->Uri(),iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetMedia:
{
SetAsync( aMessage );
CMPXCommand* cmd( CMPXCommand::NewL( aMessage.Int1() ) );
CleanupStack::PushL( cmd );
iPlayer->MediaL( *this, *cmd );
CleanupStack::PopAndDestroy( cmd );
break;
}
case EPbsGetSupportedMimeTypes:
{
CDesCArray* mimeTypes =
iPlayer->PluginHandler()->SupportedMimeTypesL();
CleanupStack::PushL(mimeTypes);
MPXUser::CreateBufferL((const MDesCArray*)mimeTypes, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(mimeTypes);
}
break;
case EPbsGetSupportedExtensions:
{
CDesCArray* exts =
iPlayer->PluginHandler()->SupportedExtensionsL();
CleanupStack::PushL(exts);
MPXUser::CreateBufferL((const MDesCArray*)exts, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(exts);
}
break;
case EPbsGetSupportedSchemas:
{
CDesCArray* schemas =
iPlayer->PluginHandler()->SupportedSchemasL();
CleanupStack::PushL(schemas);
MPXUser::CreateBufferL((const MDesCArray*)schemas, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(schemas);
}
break;
case EPbsGetNextMessage:
{
ASSERT(iMessageQueue);
iMessageQueue->SendNext(aMessage);
iCompleteRequest=EFalse;
break;
}
case EPbsCancelGetMessage:
{
ASSERT(iMessageQueue);
iMessageQueue->Reset();
break;
}
case EPbsCommand:
{
CMPXCommand* cmd( NULL );
::NewFromMessageL<CMPXMedia>(aMessage, 1, cmd);
CleanupStack::PushL(cmd);
iPlayer->CommandL(*cmd, *iMessageQueue);
CleanupStack::PopAndDestroy(cmd);
break;
}
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
case EPbsInitFromFile64:
{
RFile64 file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->Init64L(file);
file.Close();
break;
}
case EPbsInitStreamingFromFile64:
{
RFile64 file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->InitStreaming64L(file, aMessage.Int2());
file.Close();
break;
}
case EPbsGetFile64:
{
const RFile64& file = iPlayer->File64();
if (file.SubSessionHandle())
{
aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed
}
else
{
TPckgC<TInt> handle(KErrNotFound);
aMessage.Write(0, handle);
}
break;
}
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
case EPbsSetPrimaryClient:
{
aMsgHandleResult = iPlayer->ClientList()->SetPrimaryClient(*iMessageQueue);
break;
}
default:
{
PanicClient(aMessage,KErrNotSupported);
break;
}
}
MPX_DEBUG1("<---CMPXPlaybackSession::DispatchMessageL");
}
// ---------------------------------------------------------
// CPosTp141::TestInvalidPositionFieldsL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp141::TestInvalidPositionFieldsL()
{
CPosLmTextCriteria* textCriteria = CPosLmTextCriteria::NewLC();
RArray<TUint> arr;
CleanupClosePushL(arr);
textCriteria->GetPositionFieldsToSearchL(arr);
textCriteria->SetTextL(_L("*"));
textCriteria->SetPositionFieldsToSearchL(arr);
// Search with empty positionfields list, should find all landmarks
iOperation = iLandmarkSearch->StartLandmarkSearchL(*textCriteria);
ExecuteAndDeleteLD(iOperation);
TInt nr = iLandmarkSearch->NumOfMatches();
TBuf<100> buf;
buf.Format(_L("Found %d nr of matches when searching in empty position fields list"), nr);
iLog->Log(buf);
User::LeaveIfError(arr.Append(1));
User::LeaveIfError(arr.Append(2));
User::LeaveIfError(arr.Append(3));
textCriteria->SetPositionFieldsToSearchL(arr);
textCriteria->GetPositionFieldsToSearchL(arr);
TBuf<100> buf1;
for(TInt i=0;i< arr.Count();i++)
{
buf1.Format(_L(" %d position fields--%d- "),i, arr[i]);
iLog->Log(buf1);
}
//Clears the position fields list used in a search
textCriteria->ClearPositionFieldsToSearch();
textCriteria->GetPositionFieldsToSearchL(arr);
if(arr.Count()==0)
{
iLog->Log(_L("ClearPositionFieldsToSearch()-Cleared the position fields list used in a search."));
}
iLog->Log(_L("Sets the position fields list used in a search"));
User::LeaveIfError(arr.Append(0));
User::LeaveIfError(arr.Append(50));
User::LeaveIfError(arr.Append(500));
textCriteria->SetPositionFieldsToSearchL(arr);
textCriteria->GetPositionFieldsToSearchL(arr);
TBuf<100> buf2;
for(TInt i=0;i< arr.Count();i++)
{
buf2.Format(_L(" %d position fields--%d- "),i, arr[i]);
iLog->Log(buf2);
}
// Search with invalid positionfields list, should NOT find any landmarks
iOperation = iLandmarkSearch->StartLandmarkSearchL(*textCriteria);
ExecuteAndDeleteLD(iOperation);
nr = iLandmarkSearch->NumOfMatches();
buf.Format(_L("Found %d nr of matches when searching in invalid position fields"), nr);
iLog->Log(buf);
AssertTrueSecL(nr == 0, _L("We should not find any matches"));
textCriteria->ClearPositionFieldsToSearch();
CleanupStack::PopAndDestroy(&arr);
CleanupStack::PopAndDestroy(textCriteria);
}
// ---------------------------------------------------------------------------
// Constructor for CLbtContainerFilter
//
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CLbtContainerFilter::ConstructL(CLbtContainerFilter* aFilter)
{
FUNC_ENTER("CLbtContainerFilter::ConstructL");
if(!aFilter)
{
return;
}
TInt i;
// Copy hysterisis array
RArray<TReal> hystArray;
aFilter->GetHystRadiusArrayL(&hystArray);
for(i=0;i<hystArray.Count();++i)
{
iHystRadiusArray.AppendL(hystArray[i]);
}
hystArray.Close();
// Copy trigger rect array
RArray<CLbtExtendedTriggerInfo::TLbtTriggerRectArea> triggerRectAreaArray;
aFilter->GetRectAreaArrayL(&triggerRectAreaArray);
for(i=0;i<triggerRectAreaArray.Count();++i)
{
iTriggerRectAreaArray.AppendL(triggerRectAreaArray[i]);
}
triggerRectAreaArray.Close();
// Copy trigger fired array
RArray<TBool> triggerFiredArray;
aFilter->GetTriggerFiredArrayL(&triggerFiredArray);
for(i=0;i<triggerFiredArray.Count();++i)
{
iTriggerFiredArray.AppendL(triggerFiredArray[i]);
}
triggerFiredArray.Close();
// Copy SID array
RArray<TSecureId> sidArray;
aFilter->GetSidArrayL(&sidArray);
for(i=0;i<sidArray.Count();++i)
{
iSidArray.AppendL(sidArray[i]);
}
sidArray.Close();
// Copy fire on creation array
RArray<TBool> triggerFireOnCreationArray;
aFilter->GetTriggerFireOnCreationArrayL(&triggerFireOnCreationArray);
for(i=0;i<triggerFireOnCreationArray.Count();++i)
{
iTriggerFireOnCreationArray.AppendL(triggerFireOnCreationArray[i]);
}
triggerFireOnCreationArray.Close();
// Copy the startup process array
RArray<TFileName> triggerstartupProcessArray;
aFilter->GetStartupProcessArrayL(&triggerstartupProcessArray);
for(i=0;i<triggerstartupProcessArray.Count();++i)
{
iStartupProcessArray.AppendL(triggerstartupProcessArray[i]);
}
triggerstartupProcessArray.Close();
}
TVerdict CTestSetSecondaryFltStep::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
* Our implementation only gets called if the base class doTestStepPreambleL() did
* not leave. That being the case, the current test result value will be EPass.
*/
{
RArray<TUint32> *setfilters = new (ELeave)RArray<TUint32>(10);
RArray<TUint32> *getfilters = new (ELeave)RArray<TUint32>(10);
if (TestStepResult()==EPass)
{
setfilters->AppendL(KSecondaryFlt);
/**************First set primary filter*************/
iSession->Connect();
TInt iErrCode = iSession->SetSecondaryFiltersEnabled(*setfilters, ETrue);
if( iErrCode == KErrNone )
{
INFO_PRINTF2(_L("Secondary filter has been set with single filter, %d, check log"), (*setfilters)[0]);
setfilters->Reset();
iSession->GetSecondaryFiltersEnabled(*setfilters);
if( setfilters->Count() > 0 )
{
if( (*setfilters)[0] == KSecondaryFlt )
{
INFO_PRINTF1(_L("Get secondary filter successful"));
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF1(_L("Get secondary filter value does not match with set value"));
SetTestStepResult(EFail);;
}
}
else
{
INFO_PRINTF1(_L("GetFilter() Failed, can not varify the test output"));
SetTestStepResult(EFail);
}
}
}
if(TestStepResult() == EPass)
{
//prepare test
getfilters->Reset();
iSession->GetSecondaryFiltersEnabled(*getfilters);
iSession->SetSecondaryFiltersEnabled(*getfilters, EFalse);
setfilters->Reset();
getfilters->Reset();
for(TInt i = 0; i < 4096 ; i++ )
{
setfilters->AppendL((TUint32)(i));
}
TRAPD(err, iSession->SetSecondaryFiltersEnabled(*setfilters, ETrue));
if( KErrNone == err )
{
INFO_PRINTF1(_L("Secondary filter has been set with multiple filters,from 0 to 4095"));
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF2(_L("Multiple secondary filters have not been set succesfully, error code %d"), err);
SetTestStepResult(EFail);
}
//Now get the primary filter set above
iSession->GetSecondaryFiltersEnabled(*getfilters);
if( getfilters->Count() == setfilters->Count() )
{
INFO_PRINTF1(_L("setfilter and getfilter have the same count"));
for(TInt i = 0; i < getfilters->Count(); i++)
{
for(TInt j = 0; j < setfilters->Count(); j++)
{
if( (*getfilters)[i] == (*setfilters)[j] )
SetTestStepResult(EPass);
else
SetTestStepResult(EFail);
}
}
}
else
{
INFO_PRINTF1(_L("setfilter and getfilter have different counts"));
INFO_PRINTF2(_L("setfilter has %d"), setfilters->Count());
INFO_PRINTF2(_L("getfilter has %d"), getfilters->Count());
SetTestStepResult(EFail);
}
}
setfilters->Close();
getfilters->Close();
if(setfilters)
{
delete setfilters;
setfilters=NULL;
}
if(getfilters)
{
delete getfilters;
getfilters=NULL;
}
return TestStepResult();
}
void CWritableEntryMethodsStep::PrintWritableEntryContents(Swi::RSisRegistryWritableEntry &aEntry)
{
INFO_PRINTF1(_L("-------------------------------------\n"));
// get the vendor; package name
HBufC* vendor = aEntry.UniqueVendorNameL();
CleanupStack::PushL(vendor);
HBufC* package = aEntry.PackageNameL();
CleanupStack::PushL(package);
INFO_PRINTF3(_L("Package: %S from Vendor: %S"), package, vendor);
CleanupStack::PopAndDestroy(package);
CleanupStack::PopAndDestroy(vendor);
// get the localised vendor name
HBufC* vendorLocal = aEntry.LocalizedVendorNameL();
CleanupStack::PushL(vendorLocal);
INFO_PRINTF2(_L("Localised Vendor Name: %S"), vendorLocal);
CleanupStack::PopAndDestroy(vendorLocal);
// get uid
TUid uid = aEntry.UidL();
INFO_PRINTF3(_L("Package Uid: %d 0x%08x"), uid.iUid, uid.iUid);
// get the version
TVersion packageVersion = aEntry.VersionL();
INFO_PRINTF4(_L("Version %d %d %d"), packageVersion.iMajor, packageVersion.iMinor, packageVersion.iBuild );
// get sids
RArray<TUid> sids;
CleanupClosePushL(sids);
aEntry.SidsL(sids);
if (sids.Count() <= 0)
{
INFO_PRINTF1(_L("No sids installed!"));
}
else
{
for (TInt index = 0; index < sids.Count(); index++)
{
INFO_PRINTF2(_L("Sid: 0x%08x was found!"), sids[index]);
}
}
CleanupStack::PopAndDestroy(&sids);
// get language
TLanguage language = aEntry.LanguageL();
INFO_PRINTF3(_L("Package Language: %d 0x%08x"), language, language);
// get property
TInt32 propertyKey = 10;
TInt32 propertyValue = aEntry.PropertyL(propertyKey);
INFO_PRINTF3(_L("Package property: key %d value %d"), propertyKey, propertyValue);
// is present - currenty relies on default value
TBool isPresent = aEntry.IsPresentL();
INFO_PRINTF2(_L("Package present is %d"), isPresent);
// is signed
TBool isSigned = aEntry.IsSignedL();
INFO_PRINTF2(_L("Package signed is %d"), isSigned);
if (isSigned)
{
RPointerArray<HBufC8> certChains;
CleanupResetAndDestroy<RPointerArray<HBufC8> >::PushL(certChains);
aEntry.CertificateChainsL(certChains);
INFO_PRINTF2(_L("Package signed with %d chains"), certChains.Count());
CleanupStack::PopAndDestroy(&certChains);
}
// check Trust
switch(aEntry.TrustL())
{
case ESisPackageUnsignedOrSelfSigned:
INFO_PRINTF1(_L("Packaged Trust: Unsigned or self signed"));
break;
case ESisPackageCertificateChainNoTrustAnchor:
INFO_PRINTF1(_L("Packaged Trust: Certificate Chain has no trust anchor in Cert store"));
break;
case ESisPackageCertificateChainValidatedToTrustAnchor:
INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated to Trust Anchor in Cert store"));
break;
case ESisPackageChainValidatedToTrustAnchorOCSPTransientError:
INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated and OCSP Transient Error"));
break;
case ESisPackageChainValidatedToTrustAnchorAndOCSPValid:
INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated and OCSP Valid"));
break;
case ESisPackageBuiltIntoRom:
INFO_PRINTF1(_L("Packaged Trust: Built into ROM"));
break;
case ESisPackageValidationFailed:
INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validation Failed"));
break;
default:
INFO_PRINTF1(_L("Packaged Trust: Unknown"));
break;
};
// Time at which the trust was established
TTime timeStamp = aEntry.TrustTimeStampL();
TBuf <32> dateTimeText;
TRAP_IGNORE(timeStamp.FormatL(dateTimeText, _L("%H%:1%T%:2%S on %1%/1%2%/2%3")));
INFO_PRINTF2(_L("Package Trust Established: %S"), &dateTimeText);
// is in rom
TBool inRom = aEntry.IsInRomL();
INFO_PRINTF2(_L("Package inRom is %d"), inRom);
// is an augmentation
TBool isAug = aEntry.IsAugmentationL();
INFO_PRINTF2(_L("Package isAug is %d"), isAug);
// is preinstalled
/*
Sis::TInstallType installType = aEntry.InstallTypeL();
INFO_PRINTF3(_L("Package type is %d %S"),
installType, &installTypeNames[installType]);
*/
// get list of files
RPointerArray<HBufC> files;
CleanupResetAndDestroy<RPointerArray<HBufC> >::PushL(files);
aEntry.FilesL(files);
INFO_PRINTF2(_L("Package has %d files"), files.Count());
for (TInt i=0; i<files.Count(); i++)
{
INFO_PRINTF3(_L("File %d - file path %S"), i+1, files[i]);
}
CleanupStack::PopAndDestroy(&files);
// get the drive selected by the user
TChar setDrive = aEntry.SelectedDriveL();
TUint setdrive(setDrive);
INFO_PRINTF2(_L("User selected drive is %c"), setdrive);
INFO_PRINTF1(_L("-------------------------------------\n"));
}
// ---------------------------------------------------------
// CProcessorPacketData::AddLingerL
// ---------------------------------------------------------
//
void CProcessorPacketData::AddLingerL( const TInt aIapId, const TInt aLingerInterval)
{
TInt err( KErrNone );
// Open repository
CRepository* repository = CRepository::NewLC( KCRUidPDPContextManager );
// Find if an entry for "iapId" already exists in CentRep
RArray< TUint32 > foundKeys;
foundKeys.Reset();
err = repository->FindEqL( KIapColumn, // partial key
KColumnMask, // key mask
aIapId, // value
foundKeys ); // found keys
if ( err == KErrNone || err == KErrNotFound )
{
if ( foundKeys.Count() == 0 )
{
// Add a new entry
TInt arrayCount( 0 );
// Get number of iapId&linger entries in Centrep
err = repository->Get( KPdpContextManagerLingerArrayCount,
arrayCount );
if ( err == KErrNone )
{
arrayCount++;
err = repository->Create( ( KIapColumn | arrayCount ), aIapId );
if ( err == KErrNone )
{
err = repository->Create( ( KLingerColumn | arrayCount ),
aLingerInterval );
}
if ( err == KErrNone )
{
// Update number of iapId&linger entries in Centrep
err = repository->Set( KPdpContextManagerLingerArrayCount,
arrayCount );
}
}
}
else
{
// Update existing entry on current row
TInt32 row = foundKeys[ 0 ] & KRowMask;
err = repository->Set( ( KLingerColumn | row ), aLingerInterval );
}
}
foundKeys.Close();
CleanupStack::PopAndDestroy( repository );
User::LeaveIfError( err );
}
// ------------------------------------------------
// NotifyRemoved
// ------------------------------------------------
//
void CMdSNotifier::NotifyRemovedL(CMdCSerializationBuffer& aSerializedItemIds,
TBool aItemIsConfidential,
RPointerArray<HBufC>& aRemovedItemUriArray,
CMdSManipulationEngine* aMEngine )
{
aSerializedItemIds.PositionL( KNoOffset );
const TMdCItemIds& itemIds = TMdCItemIds::GetFromBufferL( aSerializedItemIds );
RArray<TItemId> objectIdArray;
CleanupClosePushL( objectIdArray );
RArray<TItemId> eventIdArray;
CleanupClosePushL( eventIdArray );
RArray<TItemId> relationIdArray;
CleanupClosePushL( relationIdArray );
//get removed item IDs
if( itemIds.iObjectIds.iPtr.iCount > 0 )
{
aSerializedItemIds.PositionL( itemIds.iObjectIds.iPtr.iOffset );
objectIdArray.ReserveL( itemIds.iObjectIds.iPtr.iCount );
for( TUint32 i = 0; i < itemIds.iObjectIds.iPtr.iCount; i++ )
{
TItemId objectId;
aSerializedItemIds.ReceiveL( objectId );
if ( objectId != KNoId )
{
objectIdArray.Append( objectId );
}
}
}
if( itemIds.iEventIds.iPtr.iCount > 0 )
{
aSerializedItemIds.PositionL( itemIds.iEventIds.iPtr.iOffset );
eventIdArray.ReserveL( itemIds.iEventIds.iPtr.iCount );
for( TUint32 i = 0; i < itemIds.iEventIds.iPtr.iCount; i++ )
{
TItemId eventId;
aSerializedItemIds.ReceiveL( eventId );
if ( eventId != KNoId )
{
eventIdArray.Append( eventId );
}
}
}
if( itemIds.iRelationIds.iPtr.iCount > 0 )
{
aSerializedItemIds.PositionL( itemIds.iRelationIds.iPtr.iOffset );
relationIdArray.ReserveL( itemIds.iRelationIds.iPtr.iCount );
for( TUint32 i = 0; i < itemIds.iRelationIds.iPtr.iCount; i++ )
{
TItemId relationId;
aSerializedItemIds.ReceiveL( relationId );
if ( relationId != KNoId )
{
relationIdArray.Append( relationId );
}
}
}
const TInt objectCount( objectIdArray.Count() );
const TInt eventCount( eventIdArray.Count() );
const TInt relationCount( relationIdArray.Count() );
if( objectCount != 0
|| eventCount != 0
|| relationCount != 0 )
{
for( TInt i = iEntries.Count() - 1; i >=0; i-- )
{
TEntry& e = iEntries[i];
// if namespace definition IDs don't match skip listener entry
if( e.NamespaceDefId() != itemIds.iNamespaceDefId )
{
continue;
}
if(aItemIsConfidential && !e.AllowConfidential())
{
continue;
}
RPointerArray<HBufC> uriArray;
CleanupResetAndDestroyPushL( uriArray );
if( e.iType & EObjectNotifyRemove && objectCount > 0 )
{
// collect matching object IDs
RArray<TItemId> matchingObjectIdArray;
CleanupClosePushL( matchingObjectIdArray );
const TBool allMatches = iComparator->MatchObjectIdsL( e.Condition(),
objectIdArray, matchingObjectIdArray );
// check is there any matches
if( allMatches || matchingObjectIdArray.Count() > 0 )
{
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TInt err( KErrNone );
if( allMatches )
{
// all matches so send whole object ID array
TRAP( err, e.TriggerL( EObjectNotifyRemove,
objectIdArray, uriArray ) );
}
else
{
TRAP( err, e.TriggerL( EObjectNotifyRemove,
matchingObjectIdArray, uriArray ) );
}
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
if( allMatches )
{
// all matches so send whole object ID array
TRAP_IGNORE( e.CacheL( EObjectNotifyRemove,
objectIdArray, uriArray ) );
}
else
{
TRAP_IGNORE( e.CacheL( EObjectNotifyRemove,
matchingObjectIdArray, uriArray ) );
}
}
}
CleanupStack::PopAndDestroy( &matchingObjectIdArray );
}
else if( e.iType & EObjectNotifyRemoveWithUri && objectCount > 0 )
{
// collect matching object IDs
RArray<TItemId> matchingObjectIdArray;
CleanupClosePushL( matchingObjectIdArray );
const TBool allMatches = iComparator->MatchObjectIdsL( e.Condition(),
objectIdArray, matchingObjectIdArray );
// check is there any matches
if( allMatches || matchingObjectIdArray.Count() > 0 )
{
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TInt err( KErrNone );
if( allMatches )
{
// all matches so send whole object ID array
TRAP( err, e.TriggerL( EObjectNotifyRemoveWithUri,
objectIdArray, aRemovedItemUriArray ) );
}
else
{
aMEngine->GetObjectUrisByIdsL( objectIdArray, uriArray );
TRAP( err, e.TriggerL( EObjectNotifyRemoveWithUri,
matchingObjectIdArray, uriArray ) );
}
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
if( allMatches )
{
// all matches so send whole object ID array
TRAP_IGNORE( e.CacheL( EObjectNotifyRemoveWithUri,
objectIdArray, aRemovedItemUriArray ) );
}
else
{
aMEngine->GetObjectUrisByIdsL( objectIdArray, uriArray );
TRAP_IGNORE( e.CacheL( EObjectNotifyRemoveWithUri,
matchingObjectIdArray, uriArray ) );
}
}
}
CleanupStack::PopAndDestroy( &matchingObjectIdArray );
}
else if( ( e.iType & EEventNotifyRemove )
&& eventCount > 0 )
{
// event condition can't contain ID conditions,
// so get all IDs
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TRAPD( err, e.TriggerL( EEventNotifyRemove,
eventIdArray, uriArray ) );
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
TRAP_IGNORE( e.CacheL( EEventNotifyRemove,
eventIdArray, uriArray ) );
}
}
else if( ( e.iType & ERelationNotifyRemove )
&& relationCount > 0 )
{
// relation condition can't contain ID conditions,
// so get all IDs
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TRAPD( err, e.TriggerL( ERelationNotifyRemove,
relationIdArray, uriArray ) );
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
TRAP_IGNORE( e.CacheL( ERelationNotifyRemove,
relationIdArray, uriArray ) );
}
}
CleanupStack::PopAndDestroy( &uriArray );
}
}
CleanupStack::PopAndDestroy( 3, &objectIdArray ); // relationIdArray, eventIdArray, objectIdArray
}
/**
* Test CJavaRegistrySuiteEntry::MIDletUidsL() method.
* 1. Test one embedded application.
* 2. Test three embedded applications.
*/
TEST(TestSuiteEntry, TestMIDletUids)
{
LOG(EJavaStorage, EInfo, "+TestMIDletUidsL");
MJavaRegistry* registry = MJavaRegistry::CreateL();
CHECK(registry != NULL);
JavaStorageApplicationEntry_t suite1;
JavaStorageEntry attr;
attr.setEntry(PACKAGE_NAME, L"TestMIdletUids");
suite1.insert(attr);
string tableName = APPLICATION_PACKAGE_TABLE;
Uid suite1Uid(L"[e1230043]");
attr.setEntry(ID, suite1Uid.toString());
suite1.insert(attr);
attr.setEntry(MEDIA_ID, L"-124614446");
suite1.insert(attr);
js->open();
js->startTransaction();
CHECK(jtu->populate(*js, tableName, suite1));
JavaStorageApplicationEntry_t midlet1;
attr.setEntry(NAME, L"MyMIDlet1");
midlet1.insert(attr);
attr.setEntry(PACKAGE_ID, suite1Uid.toString());
midlet1.insert(attr);
string appTableName = APPLICATION_TABLE;
Uid midlet1Uid(L"[e12a0077]");
attr.setEntry(ID, midlet1Uid.toString());
midlet1.insert(attr);
CHECK(jtu->populate(*js, appTableName, midlet1));
js->commitTransaction();
TUid suiteUid;
uidToTUid(suite1Uid, suiteUid);
// 1. Test one embedded application.
MJavaRegistrySuiteEntry* suiteEntry = registry->SuiteEntryL(suiteUid);
CHECK(suiteEntry != NULL);
RArray<TUid> embeddedUids;
suiteEntry->MIDletUidsL(embeddedUids);
CHECK(embeddedUids.Count() == 1);
TUid midletUid;
uidToTUid(midlet1Uid, midletUid);
CHECK(embeddedUids[0] == midletUid);
embeddedUids.Reset();
suiteEntry->Release();
JavaStorageApplicationEntry_t midlet2;
attr.setEntry(NAME, L"MyMIDlet2");
midlet2.insert(attr);
attr.setEntry(PACKAGE_ID, suite1Uid.toString());
midlet2.insert(attr);
Uid midlet2Uid(L"[e12a0007]");
attr.setEntry(ID, midlet2Uid.toString());
midlet2.insert(attr);
js->startTransaction();
CHECK(jtu->populate(*js, appTableName, midlet2));
js->commitTransaction();
JavaStorageApplicationEntry_t midlet3;
attr.setEntry(NAME, L"MyMIDlet3");
midlet3.insert(attr);
attr.setEntry(PACKAGE_ID, suite1Uid.toString());
midlet3.insert(attr);
Uid midlet3Uid(L"[e12a0117]");
attr.setEntry(ID, midlet3Uid.toString());
midlet3.insert(attr);
js->startTransaction();
CHECK(jtu->populate(*js, appTableName, midlet3));
js->commitTransaction();
// 2. Test three embedded applications.
suiteEntry = registry->SuiteEntryL(suiteUid);
CHECK(suiteEntry != NULL);
suiteEntry->MIDletUidsL(embeddedUids);
CHECK(embeddedUids.Count() == 3);
uidToTUid(midlet1Uid, midletUid);
CHECK(embeddedUids.Find(midletUid) >= 0);
uidToTUid(midlet2Uid, midletUid);
CHECK(embeddedUids.Find(midletUid) >= 0);
uidToTUid(midlet3Uid, midletUid);
CHECK(embeddedUids.Find(midletUid) >= 0);
embeddedUids.Reset();
suiteEntry->Release();
embeddedUids.Close();
// Clean
js->startTransaction();
CHECK(jtu->remove(*js, tableName, suite1));
CHECK(jtu->remove(*js, appTableName, midlet1));
CHECK(jtu->remove(*js, appTableName, midlet2));
CHECK(jtu->remove(*js, appTableName, midlet3));
js->commitTransaction();
js->close();
registry->Release();
LOG(EJavaStorage, EInfo, "-TestMIDletUidsL");
}
void CPtiVariantITUT_01DataFactory::ListLanguagesL(RArray<TInt>& aResult)
{
aResult.AppendL(ELangEnglish);
}
/** Create Multiple Contact Item with field and Add all contact
* Item to Contact database. Update the multiple contact item field value and
* verify field is being updated.
* aValue - field value
* @param aStorageType - Storage type of each field
* @param aContFieldUid - Uid of Contact field
* @param avCardMapUid - Uid of vCard
* @return - void
*/
void CTestUpdateMultipleContactsStep::CreateAndUpdateMultipleContactsL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap)
{
TPtrC value, updateVal, getUpdateValue;
CContactDatabase *dBase = NULL;
_LIT(KTestDbName, "c:contactmultiple.cdb");
TInt year, month, day,noOfCI;
TContactItemId id = 0;
RArray <TInt> idArray;
CleanupClosePushL(idArray);
//replace existing database name
dBase = CContactDatabase::ReplaceL(KTestDbName);
//Get the number of contact item from ini file
GetIntFromConfig(ConfigSection(), KNoOfContactItem, noOfCI);
//Get the int value
GetIntFromConfig(ConfigSection(), KIniYear, year);
GetIntFromConfig(ConfigSection(), KIniMonth, month);
GetIntFromConfig(ConfigSection(), KIniDay, day);
// Create contact item and add field to it
for(TInt range=0;range<noOfCI;range++)
{
CContactItem* item = CContactCard::NewLC();
CContactItemField* field = CContactItemField::NewL(aStorageType, aContFieldUid);
CleanupStack::PushL(field);
field->SetMapping(avCardMap);
if(aStorageType==KStorageTypeDateTime)
{
TDateTime date(year,(TMonth)month,day,0,0,0,0);
field->DateTimeStorage()->SetTime(date);
}
else
{
field->TextStorage()->SetTextL(aValue);
}
item->AddFieldL(*field);
CleanupStack::Pop(field);
// add contact item to database
id = dBase->AddNewContactL(*item);
idArray.Append(id);
CleanupStack::PopAndDestroy(item);
}
dBase->CloseContactL(id);
// Get the value from ini file for update
GetStringFromConfig(ConfigSection(), KIniUpdatedvalue, updateVal);
GetIntFromConfig(ConfigSection(), KIniUpdateYear, year);
GetIntFromConfig(ConfigSection(), KIniUpdateMonth, month);
GetIntFromConfig(ConfigSection(), KIniUpdateDay, day);
// update multiple contact item field value
CContactItem *readItem = NULL;
for(TInt readContact=0;readContact<noOfCI;readContact++)
{
readItem = dBase->ReadContactLC(idArray[readContact]);
CContactItemFieldSet& ContactFieldSet = readItem->CardFields();
TInt pos = ContactFieldSet.Find(aContFieldUid, avCardMap);
if(pos != KErrNotFound)
{
if(aStorageType==KStorageTypeDateTime)
{
// update the field value
TDateTime date(year,(TMonth)month,day,0,0,0,0);
ContactFieldSet[pos].DateTimeStorage()->SetTime(date);
ContactFieldSet.UpdateFieldL(ContactFieldSet[pos],pos);
// verify the updated field value
TInt upadtePos = ContactFieldSet.Find(aContFieldUid, avCardMap);
TDateTime result=ContactFieldSet[upadtePos].DateTimeStorage()->Time().DateTime();
if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
// Update the field value
ContactFieldSet[pos].TextStorage()->SetTextL(updateVal);
ContactFieldSet.UpdateFieldL(ContactFieldSet[pos],pos);
// verify the field is being updated
TInt upadtePos = ContactFieldSet.Find(aContFieldUid, avCardMap);
getUpdateValue.Set(ContactFieldSet[upadtePos].TextStorage()->Text());
//set the results
if(getUpdateValue.Compare(updateVal)==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
CleanupStack::PopAndDestroy(readItem);
}
CleanupStack::PopAndDestroy(&idArray);
delete dBase;
}
enum TVerdict CTest18ExhaustMidSizePools::doTestStepL(void)
{
//-------------- substep 1 --------------------
INFO_PRINTF1(_L(" 01 Create CMBufManager and install active scheduler:"));
CleanupStack::PushL( iActSch = new(ELeave) CActiveScheduler );
CActiveScheduler::Install(iActSch);
// Create some initial pools
// AddL(KMBuf_MBufSize, KMBuf_InitialAllocation, KMBuf_MinGrowth, KMBuf_GrowthThreshold)
// Background memory allocation (CMBufPoolManager::RunL) is used more frequently if
// the KMBuf_MinGrowth and the KMBuf_GrowthThreshold are similar in size
// Synchronous allocation (AllocPool(*poolChain, growth, ETrue)) occurs when the
// requested size (iChain.CopyIn(size)) is larger than the KMBuf_MinGrowth
// Multiple threads attempt to grow different poolchains at the same time when there
// are a greater variety of pool sizes to grow.
// 16384
TInt totalPools = 5;
TInt poolSize = (KMBufDefaultHeapSize / 2)/totalPools;
RArray<TCommsBufPoolCreateInfo> createInfoArray;
TCommsBufPoolCreateInfo createInfo;
createInfo.iBufSize = 128;
createInfo.iInitialBufs = 128;
createInfo.iGrowByBufs = 64;
createInfo.iMinFreeBufs = 40;
createInfo.iCeiling = poolSize/createInfo.iBufSize;
TCommsBufPoolCreateInfo createInfo2;
createInfo2.iBufSize = 256;
createInfo2.iInitialBufs = 64;
createInfo2.iGrowByBufs = 7;
createInfo2.iMinFreeBufs = 6;
createInfo2.iCeiling = poolSize/createInfo.iBufSize;
TCommsBufPoolCreateInfo createInfo3;
createInfo3.iBufSize = 512;
createInfo3.iInitialBufs = 32;
createInfo3.iGrowByBufs = 6;
createInfo3.iMinFreeBufs = 5;
createInfo3.iCeiling = poolSize/createInfo.iBufSize;
TCommsBufPoolCreateInfo createInfo4;
createInfo4.iBufSize = 1024;
createInfo4.iInitialBufs = 16;
createInfo4.iGrowByBufs = 5;
createInfo4.iMinFreeBufs = 4;
createInfo4.iCeiling = poolSize/createInfo.iBufSize;
TCommsBufPoolCreateInfo createInfo5;
createInfo5.iBufSize = 2048;
createInfo5.iInitialBufs = 8;
createInfo5.iGrowByBufs = 4;
createInfo5.iMinFreeBufs = 3;
createInfo5.iCeiling = poolSize/createInfo.iBufSize;
createInfoArray.Append(createInfo);
createInfoArray.Append(createInfo2);
createInfoArray.Append(createInfo3);
createInfoArray.Append(createInfo4);
createInfoArray.Append(createInfo5);
// Create 262144
CreateInstanceMBufMgrL(createInfoArray);
CleanupClosePushL(iBufPond);
createInfoArray.Close ();
RMBufAllocator allocator;
TInt allocTime128 = 0;
TInt allocTime256 = 0;
TInt allocTime512 = 0;
TInt allocTime1024 = 0;
TInt allocTime2048 = 0;
TInt allocCount128 = 0;
TInt allocCount256 = 0;
TInt allocCount512 = 0;
TInt allocCount1024 = 0;
TInt allocCount2048 = 0;
TInt allocIndex128 = 0;
TInt allocIndex256 = 0;
TInt allocIndex512 = 0;
TInt allocIndex1024 = 0;
TInt allocIndex2048 = 0;
TInt failedSizeCount = 0;
TInt counter = 0;
TUint time;
RMBufChain aChain, bChain;
RMBufChain mbuf1, mbuf2, mbuf3, mbuf4, mbuf5, mbuf6;
//-------------- substep 2 --------------------
INFO_PRINTF1(_L(" 02 Fill in the Des1 with a pattern:"));
TBuf8<2500> *aDes1 = NULL;
TRAPD(ret, aDes1 = new(ELeave) TBuf8<2500>);
if(ret != KErrNone)
{
SetTestStepResult(EFail);
return TestStepResult();
}
aDes1->SetLength(2500);
FillDes(*aDes1, 0, 2500, 1, 1);
//-------------- substep 3 --------------------
INFO_PRINTF1(_L(" 03 Start to allocate 500-bytes long RMBufs:"));
time = User::FastCounter();
ret = aChain.Alloc(500, allocator);
time = User::FastCounter() - time;
while (ret == KErrNone)
{
//Copy in Des1 into Chain
aChain.CopyIn(aDes1->LeftTPtr(500));
if (aChain.Length() != 500)
{
INFO_PRINTF1(_L("Error: Allocated RMBufChain size does not match requested:"));
failedSizeCount++;
}
switch (aChain.First()->Size())
{
case 128:
if (allocator.BytesAvailable(256) / 256 > 0)
{
INFO_PRINTF1(_L("Error: 256-bytes long RMBuf available, but allocated 128-bytes long RMBuf:"));
}
else if (allocIndex128 == 0)
{
counter++;
allocIndex128 = counter;
}
allocCount128++;
allocTime128 += time;
break;
case 256:
if (allocator.BytesAvailable(2048) / 2048 > 0)
{
INFO_PRINTF1(_L("Error: 2048-bytes long RMBuf available, but allocated 256-bytes long RMBuf:"));
}
else if (allocIndex256 == 0)
{
counter++;
allocIndex256 = counter;
}
allocCount256++;
allocTime256 += time;
break;
case 512:
if (allocIndex512 == 0)
{
counter++;
allocIndex512 = counter;
}
allocCount512++;
allocTime512 += time;
break;
case 1024:
if (allocator.BytesAvailable(512) / 512 > 0)
{
INFO_PRINTF1(_L("Error: 512-bytes long RMBuf available, but allocated 1024-bytes long RMBuf:"));
}
else if (allocIndex1024 == 0)
{
counter++;
allocIndex1024 = counter;
}
allocCount1024++;
allocTime1024 += time;
break;
case 2048:
if (allocator.BytesAvailable(1024) / 1024 > 0)
{
INFO_PRINTF1(_L("Error: 1024-bytes long RMBuf available, but allocated 2048-bytes long RMBuf:"));
}
else if (allocIndex2048 == 0)
{
counter++;
allocIndex2048 = counter;
}
allocCount2048++;
allocTime2048 += time;
break;
}
// Now grow the chain
if (allocCount256 == 1)
{
mbuf1.Append(aChain);
}
else if (allocCount512 == 1)
{
mbuf2.Append(aChain);
}
else if (allocCount512 == 2)
{
mbuf3.Append(aChain);
}
else if (allocCount512 == 3)
{
mbuf4.Append(aChain);
}
else if (allocCount2048 == 1)
{
mbuf5.Append(aChain);
}
else if (allocCount2048 == 2)
{
mbuf6.Append(aChain);
}
else
{
bChain.Append(aChain);
}
time = User::FastCounter();
ret = aChain.Alloc(500, allocator);
time = User::FastCounter() - time;
}
if (allocIndex512 == 1)
{
_LIT(aLog1," Info: %d. Time to alloc %d 512-bytes long RMBuf: %d Average: %d");
INFO_PRINTF5(aLog1, allocIndex512, allocCount512, allocTime512, allocTime512/allocCount512);
}
if (allocIndex1024 == 2)
{
_LIT(aLog2," Info: %d. Time to alloc %d 1024-bytes long RMBuf: %d Average: %d");
INFO_PRINTF5(aLog2, allocIndex1024, allocCount1024, allocTime1024, allocTime1024/allocCount1024);
}
if (allocIndex2048 == 3)
{
_LIT(aLog3," Info: %d. Time to alloc %d 2048-bytes long RMBuf: %d Average: %d");
INFO_PRINTF5(aLog3, allocIndex2048, allocCount2048, allocTime2048, allocTime2048/allocCount2048);
}
if (allocIndex256 == 4)
{
_LIT(aLog4," Info: %d. Time to alloc %d 256-bytes long RMBuf: %d Average: %d");
INFO_PRINTF5(aLog4, allocIndex256, allocCount256, allocTime256, allocTime256/allocCount256);
}
if (allocIndex128 == 5)
{
_LIT(aLog5," Info: %d. Time to alloc %d 128-bytes long RMBuf: %d Average: %d");
INFO_PRINTF5(aLog5, allocIndex128, allocCount128, allocTime128, allocTime128/allocCount128);
}
TBool firstSuccess = ETrue;
TBool secondSuccess = ETrue;
TBool thirdSuccess = ETrue;
//-------------------substep 4-----------------------------
INFO_PRINTF1(_L(" 04 Allocate 750-byte long RMBuf after deallocating 1 256-byte and 2 512-byte long RMBufs:"));
mbuf1.TrimEnd(244); // 256-byte mbuf
mbuf2.Free(); // 512-byte mbuf
mbuf3.Free(); // 512-byte mbuf
ret = aChain.Alloc(750, allocator);
if (ret != KErrNone)
{
INFO_PRINTF1(_L("Error: Couldn't allocate RMBuf:"));
firstSuccess = EFalse;
}
else
{
//Copy in Des1 into Chain
aChain.CopyIn(aDes1->LeftTPtr(750));
if (aChain.Length() != 750)
{
INFO_PRINTF1(_L("Error: Allocated RMBufChain size does not match requested:"));
firstSuccess = EFalse;
}
// 1 512-byte long RMBuf should be free
if (allocator.BytesAvailable(512) == 512)
{
INFO_PRINTF1(_L(" Info: 1 512-byte long RMBuf is free:"));
}
else
{
INFO_PRINTF1(_L("Error: 1 512-byte long RMBuf should be free, but not:"));
firstSuccess = EFalse;
}
}
bChain.Append(aChain);
//-------------------substep 5-----------------------------
INFO_PRINTF1(_L(" 05 Allocate 750-byte long RMBuf after deallocating 2 512-byte long RMBufs:"));
mbuf4.Free(); // 512-byte mbuf
ret = aChain.Alloc(750, allocator);
if (ret != KErrNone)
{
INFO_PRINTF1(_L("Error: Couldn't allocate RMBuf:"));
secondSuccess = EFalse;
}
else
{
//Copy in Des1 into Chain
aChain.CopyIn(aDes1->LeftTPtr(750));
if (aChain.Length() != 750)
{
INFO_PRINTF1(_L("Error: Allocated RMBufChain size does not match requested:"));
secondSuccess = EFalse;
}
}
bChain.Append(aChain);
//-------------------substep 6-----------------------------
INFO_PRINTF1(_L(" 06 Allocate 2100-byte long RMBuf after deallocating 2 2048-byte long RMBufs:"));
mbuf5.Free(); // 2048-byte mbuf
mbuf6.Free(); // 2048-byte mbuf
ret = aChain.Alloc(2100, allocator);
if (ret != KErrNone)
{
INFO_PRINTF1(_L("Error: Couldn't allocate RMBuf:"));
thirdSuccess = EFalse;
}
else
{
//Copy in Des1 into Chain
aChain.CopyIn(aDes1->LeftTPtr(2100));
if (aChain.Length() != 2100)
{
INFO_PRINTF1(_L("Error: Allocated RMBufChain size does not match requested:"));
thirdSuccess = EFalse;
}
}
bChain.Append(aChain);
mbuf1.Free();
bChain.Free();
delete aDes1;
//-------------- substep 7 --------------------
INFO_PRINTF1(_L(" 07 Clean up stack:"));
CleanupStack::PopAndDestroy();
CActiveScheduler::Install(NULL);
CleanupStack::PopAndDestroy(iActSch);
if (ret != KErrNone || failedSizeCount > 0 || !firstSuccess || !secondSuccess || !thirdSuccess)
{
SetTestStepResult(EFail);
return TestStepResult();
}
SetTestStepResult(EPass);
return TestStepResult();
}
/**
*
* Do the test step.
* Each test step must supply an implementation for DoTestStepL.
*
* @return "TVerdict"
* The result of the test step
*
* @xxxx
*
*/
TVerdict CTestStepPlayerBitRateWav::DoTestStepL()
{
// Printing to the console and log file
INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0850-HP"));
INFO_PRINTF1(_L("This test will read the bit rate of different wav files."));
TInt err = KErrNone;
TInt state = 0;
TVerdict result = EPass;
RArray<TPtrC> array;
array.Append(_L("PCM8BitStereo.wav"));
array.Append(_L("PCM 8-Bit,8000 Hz,128 Kbps,Stereo"));
array.Append(_L("PCM8BitMono.wav"));
array.Append(_L("PCM 8-Bit,8000 Hz,64 Kbps,Mono"));
array.Append(_L("PCM16BitStereo.wav"));
array.Append(_L("PCM 16-Bit,8000 Hz,256 Kbps,Stereo"));
array.Append(_L("PCM16BitMono.wav"));
array.Append(_L("PCM 16-Bit,8000 Hz,128 Kbps,Mono"));
array.Append(_L("uLawStereo.wav"));
array.Append(_L("u-Law 8000 Hz,128 Kbps,Stereo"));
array.Append(_L("uLawMono.wav"));
array.Append(_L("u-Law 8000 Hz,64 Kbps,Mono"));
array.Append(_L("ALawStereo.wav"));
array.Append(_L("A-Law 8000 Hz,128 Kbps,Stereo"));
array.Append(_L("ALawMono.wav"));
array.Append(_L("A-Law 8000 Hz,64 Kbps,Mono"));
CMMFMdaAudioPlayerUtility* player = CMMFMdaAudioPlayerUtility::NewL(*this);
if (player == NULL ||
iError != KErrNone)
{
return EInconclusive;
}
// check if player openned the file successfully
err = GetAudPlayerState(player, state);
if ( state != CMMFMdaAudioPlayerUtility::EStopped )
{
return EInconclusive;
}
CleanupStack::PushL(player);
TInt count = array.Count();
for (TInt iter=0; iter<count; iter+=2)
{
TUint bitRate = 0;
TBuf<256> fileBuf;
fileBuf.Append(KFilePath);
// Append the file name
fileBuf.Append(array[iter]);
INFO_PRINTF2(_L("Opening file = %S"), &fileBuf);
INFO_PRINTF2(_L("File info = %S"), &array[iter+1]);
TRAP(err,player->OpenFileL(fileBuf));
// If the opening fails, save the test result as fail and continue looping
if (err != KErrNone)
{
INFO_PRINTF2(_L("Opening file %S failed"), &fileBuf);
result = EFail;
continue;
}
CActiveScheduler::Start();
// Get the bit rate of the file being played.
err = player->GetBitRate(bitRate);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Obtaining bit rate for the file %S failed"), &fileBuf);
result = EFail;
}
else
{
INFO_PRINTF2(_L("Bit rate of the file = %d bps"), bitRate);
}
// Close the file before opening the second file
player->Close();
err = GetAudPlayerState(player, state);
if ( err != KErrNone ||
state != CMMFMdaAudioPlayerUtility::EStopped ||
iError != KErrNone)
{
result = EFail;
}
}
CleanupStack::PopAndDestroy(player);
INFO_PRINTF1(_L("Finished with this test step"));
// test steps return a result
return result;
}
