void RArrayCopyTestL()
{
test.Start(_L("Selftest of RArray CopyL"));
RArray<TInt> orig;
TInt i; // VC++
for(i=0; i<10; i++)
{
orig.AppendL(i);
}
RArray<TInt> newArray;
CopyL(orig, newArray);
test_Equal(10, newArray.Count());
for(i=0; i<10; i++)
{
test_Equal(orig[i], newArray[i])
}
orig.Close();
newArray.Close();
test.End();
}
// ---------------------------------------------------------------------------
// Sets available IAPs of this type as available in CommsDat cache
// ---------------------------------------------------------------------------
//
void TConnMonBearerWLAN::FlagAvailableIaps() const
{
LOGENTRFN("TConnMonBearerWLAN::FlagAvailableIaps()")
RArray<TUint> availableIdArray;
RArray<TUint> activeIdArray;
iConnMonIAP->GetActiveConnectionsIds( EBearerIdWLAN, activeIdArray );
if ( activeIdArray.Count() == 0 )
{
iConnMonIAP->AppendAvailableWLANIaps( availableIdArray );
}
else
{
LOGIT1("Found %d active WLAN IAPs", activeIdArray.Count())
// Policy based roaming. If current WLAN connection RSS (received
// signal strength) is not strong enough, don't give any WLAN IAPs in
// available state.
if ( iConnMonIAP->WlanRssGoodEnough() )
{
// KErrDisconnected will be returned if request for used SSID from WLAN engine fails.
TInt err = iConnMonIAP->AppendAvailableWLANIapsBySsid( availableIdArray );
if ( err != KErrNone )
{
availableIdArray.Reset();
if ( err == KErrDisconnected )
{
activeIdArray.Reset(); // No longer connected.
iConnMonIAP->AppendAvailableWLANIaps( availableIdArray );
}
}
}
else
{
// Current WLAN RSS is too weak, don't report any WLAN IAPs available.
availableIdArray.Reset();
activeIdArray.Reset();
}
}
for ( TInt i = 0; i < availableIdArray.Count(); i++ )
{
iCommsDatCache->SetAvailableIapWithId( availableIdArray[i] );
}
for ( TInt i = 0; i < activeIdArray.Count(); i++ )
{
// This will only add EasyWLAN IAP ID as available in those cases when
// the connection was started with it. This is done so there can't be a
// situation when a connection is up but ConnMon reports that
// connections IAP as unavailable. (EasyWLAN IAP has empty SSID field in
// CommsDat, so AppendAvailableWLANIapsBySsid-method will not find it).
iCommsDatCache->SetAvailableIapWithId( activeIdArray[i] );
}
availableIdArray.Close();
activeIdArray.Close();
LOGEXITFN("TConnMonBearerWLAN::FlagAvailableIaps()")
}
TBool CSwisExpressionEnvironment::DeviceLanguageL(const TDesC& aLanguageIdString)
{
TPtrC parseString(aLanguageIdString);
TBool deviceSupportedFlag;
TInt langId = ParseLanguageId(parseString);
if(langId == KErrNotFound)
{
return EFalse;
}
//Set the iHasDeviceSupportedLanguages flag
(const_cast <CApplication&> (iApplication)).SetDeviceSupportedLanguages(ETrue);
deviceSupportedFlag = iApplication.IsDeviceMatchingLanguage(langId);
if ( !deviceSupportedFlag )
{
RSisHelper iSisHelper = (const_cast <CApplication&> (iApplication)).GetSisHelper();
RArray<TInt> deviceSupportedLanguages = (const_cast <CApplication&> (iApplication)).GetDeviceSupportedLanguages();
TInt size = deviceSupportedLanguages.Count();
RArray<TLanguage> equivalentLangArray;
CleanupClosePushL(equivalentLangArray);
for ( TInt i=0; i < size; i++)
{
iSisHelper.GetEquivalentLanguageListL((TLanguage)deviceSupportedLanguages[i],equivalentLangArray);
TInt equivalentArraySize = equivalentLangArray.Count();
for ( TInt j=0; j < equivalentArraySize; j++ )
{
if (equivalentLangArray[j] == langId )
{
(const_cast <CApplication&> (iApplication)).SetLanguageMatch(ETrue);
(const_cast <CApplication&> (iApplication)).PopulateMatchingDeviceLanguagesL(langId);
equivalentLangArray.Close();
CleanupStack::Pop(&equivalentLangArray);
return ETrue;
}
}
equivalentLangArray.Close();
}
CleanupStack::Pop(&equivalentLangArray);
}
// Set the iHasMatchingLanguages flag if there is an exact match between the
// languages which device supports and SUPPORTED_LANGUAGE token in PKG file.
if(deviceSupportedFlag)
{
(const_cast <CApplication&> (iApplication)).SetLanguageMatch(ETrue);
(const_cast <CApplication&> (iApplication)).PopulateMatchingDeviceLanguagesL(langId);
}
return deviceSupportedFlag;
}
TInt CTestHistoryLog::AddMoreThanFiveJobsL( CStifItemParser& /*aItem*/ )
{
for (TInt i = 0; i < KMaxMsgSize; i++)
{
RArray<TInt> tasks;
tasks.Append(KTaskId1);
tasks.Append(KTaskId2);
CSyncMLHistoryJob * entry = CSyncMLHistoryJob::NewL(i, tasks );
CleanupStack::PushL(entry);
tasks.Reset();
tasks.Close();
iHistoryArray->AppendEntryL(entry);
if (iOwnerShip)
{
CleanupStack::Pop(entry);
}
else
{
CleanupStack::PopAndDestroy(entry);
}
}
TL(iHistoryArray->Count() == KMaxMsgSize);
return KErrNone;
}
TInt CTestHistoryLog::AddNewJobEntryL( CStifItemParser& /*aItem*/ )
{
TInt arrayCount = iHistoryArray->Count() + 1;
TInt profileId(1);
RArray<TInt> tasks;
tasks.Append(KTaskId1);
tasks.Append(KTaskId2);
CSyncMLHistoryJob * entry = CSyncMLHistoryJob::NewL(profileId, tasks );
CleanupStack::PushL(entry);
tasks.Reset();
tasks.Close();
iHistoryArray->AppendEntryL(entry);
TL(iHistoryArray->Count() == arrayCount);
if (iOwnerShip)
{
CleanupStack::Pop(entry);
}
else
{
CleanupStack::PopAndDestroy(entry);
}
return KErrNone;
}
//*************************************************************************************
EXPORT_C void ASTstAlarmTest::TestClearStoreL()
//
// Clear any settings that may have been stored
// Method could leave when trying to get list of all alarm categories in use within the alarm server.
//
{
iTest(iAlarmServer.Handle() != KNullHandle);
// Delete all alarms
RArray<TAlarmCategory> categories;
iAlarmServer.GetAvailableCategoryListL(categories);
TInt count = categories.Count();
for(TInt i=0; i<count; i++)
{
const TAlarmCategory category = categories[i];
iTest(iAlarmServer.AlarmDeleteAllByCategory(category, EFalse) == KErrNone);
}
categories.Close();
// Restore alarm sound
iAlarmServer.SetAlarmSoundState(EAlarmGlobalSoundStateOn);
// Check there aren't any queued alarms (not a particularly good
// test, but better than nothing).
count = iAlarmServer.NumberOfAlarmsActiveInQueue();
iTest(!count);
}
void CUninstallMachine::PostJournalFinalizationL(TInt)
{
if (!iPlan)
{
return;
}
DEBUG_PRINTF(_L8("Uninstall Machine - PostJournalFinalization"));
RSisLauncherSession launcher;
if (launcher.Connect() != KErrNone)
{
DEBUG_PRINTF(_L8("Uninstall Machine - Failed to connect to SisLauncher"));
return;
}
CleanupClosePushL(launcher);
//Notify apparc for the the change in the Applications
RArray<TAppUpdateInfo> affectedApps;
CleanupClosePushL(affectedApps);
iPlan->GetAffectedApps(affectedApps);
if (affectedApps.Count() > 0)
{
launcher.NotifyNewAppsL(affectedApps);
}
affectedApps.Close();
CleanupStack::PopAndDestroy(2, &launcher); //affectedApps
}
void CBCTestPtiEngine::TestLanguageL()
{
CArrayFixFlat<TInt>* langs = new (ELeave) CArrayFixFlat<TInt>(100);
CleanupStack::PushL(langs);
iEngine->GetAvailableLanguagesL(langs);
AssertTrueL(langs->Count()>0, _L("available languages got"));
CleanupStack::PopAndDestroy( 1 ); // cores, langs
RArray<TInt> langRefs;
iEngine->GetAvailableLanguagesL(langRefs);
AssertTrueL(langRefs.Count()>0, _L("available languages got into RArray"));
//
//activate
//
if(langRefs.Count())
{
MPtiLanguage *lan = iEngine->GetLanguage(langRefs[0]);
if (lan->HasInputMode(EPtiEngineMultitapping))
{
iEngine->ActivateLanguageL(lan->LanguageCode(), EPtiEngineMultitapping);
AssertTrueL( ETrue, _L("activate multitapping"));
}
else
{
iEngine->ActivateLanguageL(lan->LanguageCode(), EPtiEnginePredictive);
AssertTrueL( ETrue, _L("activate predictive"));
}
}
langRefs.Close();
}
// ---------------------------------------------------------
// Store input language to Repository
// ---------------------------------------------------------
//
void CGSPenInputModel::SetInputLanguageL()
{
RArray<TInt> languageCodeArray;
iPtiEngine->GetAvailableLanguagesL(languageCodeArray);
const TInt count = languageCodeArray.Count();
if (iLanguageIndex <= count)
{
iInputLanguage = languageCodeArray[iLanguageIndex];
iAknfepRepository->Set(KAknFepInputTxtLang, iInputLanguage);
}
languageCodeArray.Reset();
languageCodeArray.Close();
// Remember which chinese language variant was used
// for the chinese find method setting
TUint key = ChineseFindMethodCRKey();
if(key != iLastChineseFindMethodItem)
{
iAknRepository->Set(KAknAdaptiveSearchLastChinese, (int)key);
iLastChineseFindMethodItem = key;
}
}
// ----------------------------------------------------
// CFindItemVoIPExtension::VoIPProfilesExistL
//
// ----------------------------------------------------
TBool CFindItemVoIPExtension::VoIPProfilesExistL() const
{
#ifndef RD_VOIP_REL_2_2
TBool isProfiles = EFalse;
if ( iVoIPSupported )
{
RArray<TUint32> profileArray;
CRCSEProfileRegistry* rcseProfileRegistry = CRCSEProfileRegistry::NewLC();
rcseProfileRegistry->GetAllIdsL( profileArray );
if ( profileArray.Count() > 0 )
{
isProfiles = ETrue;
}
profileArray.Close();
CleanupStack::PopAndDestroy(); // rcseProfile
}
return isProfiles;
#else // RD_VOIP_REL_2_2
TBool ret( EFalse );
if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )
{
ret = iSPSettings->IsFeatureSupported( ESupportVoIPFeature );
}
return ret;
#endif // !RD_VOIP_REL_2_2
}
QList<int> S60CameraSettings::supportedIsoSensitivities()
{
QList<int> isoSentitivities;
#ifdef POST_31_PLATFORM
if (m_advancedSettings) {
RArray<TInt> supportedIsoRates;
TRAPD(err, m_advancedSettings->GetSupportedIsoRatesL(supportedIsoRates));
if (err != KErrNone)
if (err != KErrNotSupported)
emit error(QCamera::CameraError, QString("Failure while querying supported iso sensitivities."));
else {
for (int i = 0; i < supportedIsoRates.Count(); i++) {
int q = supportedIsoRates[i];
isoSentitivities.append(q);
}
}
supportedIsoRates.Close();
}
else
emit error(QCamera::CameraError, QString("Unexpected camera error."));
return isoSentitivities;
#else // S60 3.1 Platform
return isoSentitivities;
#endif // POST_31_PLATFORM
}
// ---------------------------------------------------------------------------
// CJavaRegistry::SuiteEntryExistsL
// ---------------------------------------------------------------------------
//
TBool CJavaRegistry::SuiteEntryExistsL(TUid aSuiteUid) const
{
JELOG2(EJavaStorage);
if (aSuiteUid == TUid::Null())
{
User::Leave(KErrArgument);
}
RArray<TUid> suiteUids;
// New registry filters non-present applictions.
iRegistry->GetRegistryEntryUidsL(Java::EMidp2MidletSuite, suiteUids);
int result = suiteUids.Find(aSuiteUid);
suiteUids.Close();
TBool exists = EFalse;
if (KErrNotFound != result)
{
exists = ETrue;
}
return exists;
}
void CIkeV2PkiService::CIkeV2PkiServiceApplUidArrayCleanup(TAny* any)
{
RArray<TUid>* applUidList = reinterpret_cast<RArray<TUid>*>(any);
applUidList->Reset();
applUidList->Close();
delete applUidList;
}
QList<qreal> S60CameraSettings::supportedShutterSpeeds()
{
QList<qreal> speeds;
#ifdef POST_31_PLATFORM
if (m_advancedSettings) {
RArray<TInt> supportedSpeeds;
TValueInfo info = ENotActive;
TRAPD(err, m_advancedSettings->GetShutterSpeedsL(supportedSpeeds, info));
if (err != KErrNone)
if (err != KErrNotSupported)
emit error(QCamera::CameraError, QString("Failure while querying supported shutter speeds."));
else {
for (int i = 0; i < supportedSpeeds.Count(); i++) {
qreal q = supportedSpeeds[i];
speeds.append(q);
}
}
supportedSpeeds.Close();
}
else
emit error(QCamera::CameraError, QString("Unexpected camera error."));
return speeds;
#else // S60 3.1 Platform
return speeds;
#endif // POST_31_PLATFORM
}
// ---------------------------------------------------------------------------
// CLbtAppChangeHandler::HandleAppListEvent
// ---------------------------------------------------------------------------
//
void CLbtAppChangeHandler::HandleAppListEvent(TInt /*aEvent*/)
{
FUNC_ENTER("CLbtAppChangeHandler::HandleAppListEvent");
if( iOperation == EOpNone && !IsActive() )
{
iOperation = EOpRegiseteredForListPoplulation;
iAppArcSession.RegisterListPopulationCompleteObserver(iStatus);
SetActive();
return;
}
iOperation = EOpNone;
RArray<TLbtAppInfo> newAppList;
// First get the set of installed applications in the system
iAppArcSession.GetAllApps();
TApaAppInfo appInfo;
TInt error = iAppArcSession.GetNextApp(appInfo);
while(KErrNone == error)
{
TLbtAppInfo lbtAppInfo;
lbtAppInfo.iUid = appInfo.iUid;
lbtAppInfo.iFullName.Zero();
lbtAppInfo.iFullName.Copy( appInfo.iFullName );
TRAPD(err, newAppList.AppendL(lbtAppInfo));
if(err != KErrNone)
{
break;
}
error = iAppArcSession.GetNextApp(appInfo);
}
LOG1("newAppList.Count():%d",newAppList.Count());
LOG1("iCurrentInstalledApps.Count():%d",iCurrentInstalledApps.Count());
if(newAppList.Count() > iCurrentInstalledApps.Count())
{
HandleAppListAdditionEvent(newAppList);
}
else
{
LOG("newAppList.Count() < iCurrentInstalledApps.Count()");
HandleAppListRemovalEvent(newAppList);
}
iCurrentInstalledApps.Reset();
for( TInt i=0;i<newAppList.Count();i++ )
{
TInt error = iCurrentInstalledApps.Append( newAppList[i] );
if( error != KErrNone )
{
LOG1("Failed to append new applist to the array:%d",error);
break;
}
}
newAppList.Close();
}
void CBCTestKeymap::TestCreateL()
{
//raw data format:
//
// #map //=2*KPtiNumKeys*sizeof(TPtiKeyMapping) = 2*12*(2*sizeof(int))
// {index, chars}, {index, chars}, ... , {index, chars} //lower case
// {INDEX, CHARS}, {INDEX, CHARS}, ... , {INDEX, CHARS} //upper case
//
// #chars
// char1, char2, ... , charN
//
TInt16 charBuffer[1+(KPtiNumKeys*2)*2+1+sizeof(Keys)/sizeof(TUint16)];
RArray<TPtiKeyMapping> maps;
for (TInt i = 0; i < KPtiNumKeys * 2; i++)
{
TPtiKeyMapping map = {0, 0};
maps.AppendL( map );
}
TInt16* ptr = charBuffer+1+maps.Count()*2+1;
TInt curKey=0;
TInt index=0;
for (TInt i = 0; i < sizeof(Keys)/sizeof(TUint16)-1; ++i)
{
if (Keys[i] == '\t')
{
maps[++curKey].iIndex = index;
continue;
}
*(ptr+index)= Keys[i];
index++;
maps[curKey].iNumChars++;
}
charBuffer[0]=maps.Count();
ptr=charBuffer+1;
for(TInt i=0; i<maps.Count(); ++i)
{
*ptr=maps[i].iIndex;
ptr++;
*ptr=maps[i].iNumChars;
ptr++;
}
*ptr=index;
maps.Close();
Teardown();
TRAPD(err, iMap = CPtiKeyMappings::NewL(charBuffer));
if(err == KErrCorrupt)
{
AssertTrueL(ETrue, _L("data format err"));
}
else
{
AssertNotNullL(iMap, _L("created by NewL from raw data"));
}
}
// Tokenize the property list taken from ini file and check for non-existence of these properties in the exported file.
void CTestCompareCntFiles::TokenizeAndCheckNoFieldL()
{
TBool result = EFalse;
RArray<TPtrC> fieldList;
CleanupClosePushL(fieldList);
iExportObj->TokenizeStringL(iNoField, fieldList);
TInt count = fieldList.Count();
for(TInt i = 0;i < count;i++)
{
result = CheckForNoFieldL(iExportFilePath, fieldList[i]);
if(result)
{
INFO_PRINTF1(_L("Success: Property not present in vCard"));
}
else
{
INFO_PRINTF1(_L("Error: Property present in vCard"));
SetTestStepResult(EFail);
break;
}
}
CleanupStack::PopAndDestroy();
fieldList.Close();
}
TBool CHuiFxEngine::FxmlUsesInput1(CHuiFxEffect& aEffect)
{
RArray<THuiFxVisualSrcType> array;
aEffect.FxmlVisualInputs(array);
TInt c = array.Count();
for(TInt i = 0; i<c; i++)
{
THuiFxVisualSrcType val = array[i];
if (val == EVisualSrcInput1)
{
array.Close();
return ETrue;
}
}
array.Close();
return EFalse;
}
// ---------------------------------------------------------
// Get Popup Query languages from ptiengine
// ---------------------------------------------------------
//
void CGSPenInputModel::GetPopupQuerylanguagesFromPtiL(CDesCArray* aLanguageNames)
{
RArray<TInt> languageCodeArray;
iPtiEngine->GetAvailableLanguagesL(languageCodeArray);
// Item format should be "<icon_index>\t<item_text>"
_LIT( KIconIndexSelected, "0\t" );
_LIT( KIconIndexNotSelected, "\t" );// No icon
MPtiLanguage* lang = NULL;
TBuf<KISOCodeLength> isoCodeName;
for (TInt index = 0; index < languageCodeArray.Count(); index ++)
{
lang = iPtiEngine->GetLanguage(languageCodeArray[index]);
if (!lang)
{
User::Leave(KErrCorrupt);
}
// Buffer should contain both tabulator string and localized name:
HBufC* langStrBuf = HBufC::NewL(lang->LocalizedName().Length() + 7);
CleanupStack::PushL(langStrBuf);
TPtr langStrPtr = langStrBuf->Des();
// If language is current language - use selected icon in lbx:
if(lang->LanguageCode() == InputLanguage())
{
langStrPtr.Append(KIconIndexSelected);
iLanguageIndex = index;
}
else
{
langStrPtr.Append(KIconIndexNotSelected);
}
langStrPtr.Append(lang->LocalizedName());
//AdjustLanguageName(lang->LanguageCode(), langStrPtr);
/*if (AknPenInputUtils::GetISOLanguageCode(TLanguage(lang->LanguageCode()),
isoCodeName))
{
langStrPtr.Append(KLeftBracket);
langStrPtr.Append(isoCodeName);
langStrPtr.Append(KRightBracket);
}*/
aLanguageNames->AppendL(langStrPtr);
CleanupStack::PopAndDestroy(langStrBuf);
}
languageCodeArray.Reset();
languageCodeArray.Close();
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C void PosLmLandmarkHandler::ReadLandmarkL(
RDbRowSet& aView,
CPosLmLocalDbAccess& aDbAccess,
CPosLandmark& aLandmark)
{
RArray<TUint> dummy; // Not used here. All fields should be read.
ReadLandmarkL(
aView, aDbAccess, aLandmark, CPosLandmark::EAllAttributes, EFalse, dummy);
dummy.Close();
}
void Ut_CSpsBufferedPublisher::Ut_CSpsBufferedPublisher_DataValidyL()
{
for( TInt i(0); i < 100000; i++ )
{
CSpsBufferedPublisher::SetL( KUidSystemCategory, KSPNotifyChangeKey, i );
RArray<TUint32> array;
iPublisher->GetL( array );
EUNIT_ASSERT_EQUALS( 1, array.Count() );
EUNIT_ASSERT_EQUALS( i, array[0] );
array.Close();
}
RArray<TUint32> array;
iPublisher->GetL( array );
EUNIT_ASSERT_EQUALS( 0, array.Count() );
array.Close();
}
// ---------------------------------------------------------------------------
// Order of function calls fix the layout of grid in portrait and landscape modes.
// ---------------------------------------------------------------------------
//
void CAlfExAnalogDialerControl::SetWeightsOfGridL( CAlfGridLayout& aGridLayout,
TLayoutMode aLayout,
TInt aSquareSide,
TInt aLongerSide,
TInt& aPlateTop)
{
// Set up a variable for default value.
RArray<TInt> weightsDefault;
User::LeaveIfError(weightsDefault.Append(1));
// sets weights of grid. Use pizels of application window size to get exact adjustment of pane sizes
RArray<TInt> weights;
if (aLayout == ELayoutAnalogDialerPortrait)
{
// top: display; take rest what dialer plate leaves for number display
User::LeaveIfError(weights.Append(aLongerSide-aSquareSide));
// bottom: dialer, which must be square
User::LeaveIfError(weights.Append(aSquareSide));
aGridLayout.SetRowsL(weights);
// default weight for dimension, which is 1. Needed, because weights are reset
aGridLayout.SetColumnsL(weightsDefault);
// Offset to the plate in Y-dimension is height of number display
aPlateTop = aLongerSide-aSquareSide;
}
else
{
// left: dialer, which must be square
User::LeaveIfError(weights.Append(aSquareSide));
// right: display; take rest what dialer plate leaves for number display
User::LeaveIfError(weights.Append(aLongerSide-aSquareSide));
// default weight for dimension, which is 1. Needed, because weights are reset
aGridLayout.SetRowsL(weightsDefault);
aGridLayout.SetColumnsL(weights);
aPlateTop = 0;
}
weights.Close();
weightsDefault.Close();
}
void Ut_CSpsBufferedPublisher::Ut_CSpsBufferedPublisher_DataSizeL()
{
const TUint32 data( 0xFFFFFFFF );
CSpsBufferedPublisher::SetL( KUidSystemCategory, KSPNotifyChangeKey, data );
RArray<TUint32> array;
iPublisher->GetL( array );
EUNIT_ASSERT_EQUALS( 1, array.Count() );
EUNIT_ASSERT_EQUALS( data, array[0] );
array.Close();
}
// handle enhanced notification
void CNotifyWatcher::HandleNotificationEnhanced(TBool aLastTime)
{
TInt num = iCounter;
iMeanCounter++;
TFsNotification::TFsNotificationType type;
const TFsNotification* notification;
while((notification = iNotify->NextNotification())!= NULL)
{
iCounter++;
type = notification->NotificationType();
if (iOption & EBigBuffer)
{
SAFETEST1((type & OpNotifyMapping(iOption, iCurrentOp)), (iOption & KNotifyTreadIdMask));
}
else
{
SAFETEST1((type & (OpNotifyMapping(iOption, iCurrentOp) | TFsNotification::EOverflow)), (iOption & KNotifyTreadIdMask));
}
if(iOption & EReportChg)
{
if (type & TFsNotification::EOverflow)
{
iOverflowCounter++;
RArray<TEntry> newEntries;
FullDirectoryScanL(newEntries);
MakeChangeRecordL(newEntries);
newEntries.Close();
}
else
{
TPtrC ptr;
notification->Path(ptr);
TFileName name;
name.Copy(ptr);
TInt r = iRecords.Append(name);
SAFETEST2(r, KErrNone, (iOption & KNotifyTreadIdMask));
}
}
}
if (aLastTime)
{
if (num == iCounter) // no new notification so this iteration doesn't count
{
iMeanCounter--;
}
return;
}
iNotify->RequestNotifications(iStatus);
SetActive();
}
TBool CHuiFxEffectCacheEffectNode::FxmlUsesInput1()
{
CHuiFxEffect *effect = iEffect;
RArray<THuiFxVisualSrcType> array;
effect->FxmlVisualInputs(array);
TInt c = array.Count();
for(TInt i = 0; i<c; i++)
{
THuiFxVisualSrcType val = array[i];
if (val == EVisualSrcInput1)
{
array.Close();
return ETrue;
}
}
array.Close();
return EFalse;
}
void MsgStoreHandler::RunL()
{
TSsmState ssmState = iStateAwareSession.State();
if (ssmState.MainState() != ESsmNormal)
{
iStateAwareSession.RequestStateNotification(iStatus);
SetActive();
}
else
{
//Create the query/operation object
CMsvSearchSortOperation *operation = CMsvSearchSortOperation::NewL(*iMsvSession);
CleanupStack::PushL(operation);
CMsvSearchSortQuery *query = CMsvSearchSortQuery::NewL();
CleanupStack::PushL(query);
//set the query options
query->SetParentId(KMsvGlobalInBoxIndexEntryId);
query->SetResultType(EMsvResultAsTMsvId);
query->AddSearchOptionL(EMsvMtmTypeUID, KSenduiMtmSmsUidValue, EMsvEqual);
query->AddSearchOptionL(EMsvUnreadMessages, ETrue);
CleanupStack::Pop(query);
CMsvOperationActiveSchedulerWait* wait = CMsvOperationActiveSchedulerWait::NewLC();
//ownership of Query transferred to Operation
operation->RequestL(query, EFalse, wait->iStatus);
wait->Start();
//Get No of entries
RArray<TMsvId> messageArray;
operation->GetResultsL(messageArray);
CMsvEntry* entry = NULL;
for (TInt i = 0; i < messageArray.Count(); ++i)
{
entry = iMsvSession->GetEntryL(messageArray[i]);
TMsvSmsEntry smsEntry = entry->Entry();
TSmsDataCodingScheme::TSmsClass classType(TSmsDataCodingScheme::ESmsClass0);
if (smsEntry.Class(classType))
{
HandleClass0SmsL(entry, smsEntry.Id());
}
else
{
delete entry;
entry = NULL;
}
}
messageArray.Close();
CleanupStack::PopAndDestroy(2, operation);
}
}
/**
Run check buffers on the supplied TAddressParms array
*/
TBool DoTferParmTestL(const TAddressParms* aParms, TInt aCount, TBool aAllowRepeat, TBool aPositive)
{
_LIT(KPositive, "positive");
_LIT(KNegative, "negative");
test.Printf(_L("CheckBuffers %S test: %d args, repeats allowed %d\n"),
(aPositive ? &KPositive : &KNegative), aCount, aAllowRepeat);
RArray<const TAddressParms> array;
ArrayAppendL(array, aParms, aParms + aCount);
TPreTransferIncrBytes preTran;
TBool r = preTran.CheckBuffers(array, aAllowRepeat);
array.Close();
return r;
}
HX_RESULT HXAudioConfiguratorAAC::ConfigureEAACPDecoder(CMMFCodec* pDecoder)
{
HX_RESULT result = HXR_OK;
HXLOGL2(HXLOG_MDFA, "HXAudioConfiguratorAAC::ConfigureEAACPDecoder()");
HXLOGL2(HXLOG_MDFA, "Samples Per Second : %lu", m_ulSamplesPerSecond);
HXLOGL2(HXLOG_MDFA, "Number of Channels : %u", m_uNumChannels);
HXLOGL2(HXLOG_MDFA, "Profile Type : %d", m_nProfileType);
HXLOGL2(HXLOG_MDFA, "Profile Type: Unknown(-1), MP(0), LC(1), SSR(2), LTP(3)");
HXLOGL2(HXLOG_MDFA, "Samples Per Frame : %u", m_uSamplesPerFrame);
HXLOGL2(HXLOG_MDFA, "Frame Length : %u", m_uInputFrameLength);
HXLOGL2(HXLOG_MDFA, "Samples Per Second : %lu", m_ulSamplesPerSecond);
HXLOGL2(HXLOG_MDFA, "Down Sample Mode : %u", m_uDownSampleMode);
HXLOGL2(HXLOG_MDFA, "Bits Per Sample : %u", m_uBitsPerSample);
HXLOGL2(HXLOG_MDFA, "Output SamplesPerSecond: %lu", m_ulOutSamplesPerSecond);
HXLOGL2(HXLOG_MDFA, "Extension Object Type : %u", m_uExtObjectType);
HXLOGL2(HXLOG_MDFA, "Object Type : Main(1), LC(2), SSR(3), LTP(4), SBR(5), SCALABLE(6), TWINVQ(7)");
RArray<TInt> configParams;
configParams.Append(m_ulSamplesPerSecond); // 0: Input Sample Frequency
configParams.Append(m_uNumChannels); // 1: Num Channels [1|2]
configParams.Append(m_nProfileType); // 2: Input Profile Object type [1 - LC, 3 - LTP]
configParams.Append(m_uSamplesPerFrame); // 3: Output Frame Size
configParams.Append(m_uInputFrameLength); // 4: Input Frame Len [1024, 960]
configParams.Append(m_ulSamplesPerSecond); // 5: Input Sample Rate
configParams.Append(0); // 6: 0
configParams.Append(m_uDownSampleMode); // 7: Down Sample Mode [0|1]
configParams.Append(m_uBitsPerSample); // 8: Sample resolution, 8Khz (8-bit PCM) or 16Khz (16-bit)
configParams.Append(m_ulOutSamplesPerSecond); // 9: Output Sample Frequency
configParams.Append(m_uExtObjectType); // 10: Extension Object Type
TUid codecId = TUid::Uid(KUidMmfCodecAudioSettings);
TRAPD(err, pDecoder->ConfigureL(codecId, (TDesC8&) configParams));
if(KErrNone != err)
{
result = HXR_FAIL;
}
configParams.Close();
// don't change the sample rate if we operate the SBR tool in
// downsampled mode
if(m_uDownSampleMode == 0)
{
// now that we're done configuring, update the true sample rate
m_ulSamplesPerSecond = m_ulOutSamplesPerSecond;
}
return result;
}
// -----------------------------------------------------------------------------
// CSisxUIStartupFile::RemovePrivateFile
// Deletes the old startup file from private directory and returns all startup
// items in that file.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CSisxUIStartupFile::RemovePrivateFile( RArray<TStartupTaskParam>& aStartupItems )
{
TInt result( KErrNone );
TRAP( result, ReadPrivateStartupItemsL( aStartupItems ) );
if ( result == KErrNone )
{
iFileSession.Delete( *iPrivateFile );
}
else
{
// Do some cleanup
aStartupItems.Close();
}
return result;
}
/**
@SYMTestCaseID PDS-SQL-UT-4162
@SYMTestCaseDesc CSqlServer::GetBackUpListL() file I/O error simulation test
@SYMTestPriority High
@SYMTestActions Calls CSqlServer::GetBackUpListL() in a file I/O error simulation loop.
@SYMTestExpectedResults Test must not fail
@SYMDEF DEF144096
*/
void GetBackupListFileIoErrorTest()
{
CSqlServer* server = NULL;
TRAPD(err, server = CreateSqlServerL());
TEST2(err, KErrNone);
for(TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
{
TheTest.Printf(_L("===Simulated error: %d\r\nIteration: "), fsError);
err = KErrNotFound;
TInt fileCnt = 0;
TInt cnt=0;
while(err<KErrNone)
{
TheTest.Printf(_L("%d "), cnt);
(void)server->Fs().SetErrorCondition(fsError, cnt);
const TUid KDbUd = {0x98765432};
RArray<HBufC*> files;
TRAP(err, server->GetBackUpListL(KDbUd, EDriveC, files));
fileCnt = files.Count();
if(err == KErrNone)
{
//No directories should be returned in the list of files for backup
for(TInt i=0;i<fileCnt;++i)
{
TPtrC fname = files[i]->Des();
TInt rc = KPrivateSubDir().CompareF(fname);
TEST(rc != 0);
}
}
for(TInt j=0;j<files.Count();++j)
{
delete files[j];
}
files.Close();
(void)server->Fs().SetErrorCondition(KErrNone);
if(err != KErrNone)
{
++cnt;
}
}
TEST2(err, KErrNone);
TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\nFile count: %d\r\n"), cnt, fileCnt);
}
delete server;
}
