// ---------------------------------------------------------
// TDdParser::MediaObjAttribute() // for OMA v2
// ---------------------------------------------------------
//
TDdParser::TDdAttr TDdParser::MediaObjAttribute( const TDesC& aAttrName ) const
{
TDdAttr attr = EDdUnknownAttr;
if ( !aAttrName.Compare( KDdUrl ) )
{
attr = EDdUrl;
}
else if ( !aAttrName.Compare( KDdSize ) )
{
attr = EDdSize;
}
else if ( !aAttrName.Compare( KDdType ) )
{
attr = EDdType;
}
else if ( !aAttrName.CompareF( KDdProgressiveDl ) )
{
attr = EDdProgressiveDl;
}
else if ( !aAttrName.CompareF( KDdSuppressUserConfirmation ) )
{
attr = EDdSuppressUserConfirmation;
}
else if ( !aAttrName.Compare( KDdMeta ) )
{
attr = EDdMeta;
}
return attr;
}
/** Exports a vCard with version 2.1 or 3.0
@param adBase The database to export from
@param aStandard The PBAP version to export
@param aIdArray The contact item ID array to export from database
@param aWriteStream The write stream to write to
@param aContactFilter Filter
*/
void CContactsPBAPExportUtilityClass::ExportvCardL(CContactDatabase* adBase, const TDesC& aStandard, CContactIdArray* aIdArray, RWriteStream& aWriteStream, TInt64 aContactFilter)
{
TVCardVersion version(EVCardUDEF);
TBool enableTel = EFalse;
BaseTestStepReference().GetBoolFromConfig(BaseTestStepReference().ConfigSection(), KTelProp, enableTel);
if(aStandard.Compare(KVersion21) == 0)
{
version = EPBAPVCard21;
}
if(aStandard.Compare(KVersion30) == 0)
{
version = EPBAPVCard30;
}
else
{
if(aStandard.Compare(KVersionStd21) == 0)
{
version = EVCard21;
adBase->ExportSelectedContactsL(TUid::Uid(KUidVCardConvDefaultImpl), *aIdArray, aWriteStream, 0, aContactFilter, this, version ,enableTel);
return;
}
}
adBase->ExportSelectedContactsL(TUid::Uid(KUidPBAPVCardConvImpl), *aIdArray, aWriteStream, 0, aContactFilter, this, version ,enableTel);
}
/**
ConstructL()
Reads the machine name from the Machine config file("c:\\msgtest\\MachineName.txt")
and constructs the data members.
@param aPtrEmailAdd
*/
EXPORT_C void CT_MsgUtilsConfigFileMachineName::ConstructL(const TDesC& aPtrEmailAdd)
{
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFile file;
User::LeaveIfError(file.Open(fs, KFileName, EFileRead));
CleanupClosePushL(file);
TInt fileSize;
User::LeaveIfError(file.Size(fileSize));
iMachineName = HBufC8::NewL(fileSize);
TPtr8 bufferPtr = iMachineName->Des();
User::LeaveIfError(file.Read(bufferPtr));
if (aPtrEmailAdd.Compare(_L("NONE"))==0)
iMachineNameEmail = HBufC::NewL(iMachineName->Length() + KAtEmailAddress.iTypeLength);
else
iMachineNameEmail = HBufC::NewL(iMachineName->Length() + aPtrEmailAdd.Length() + 1);
iMachineNameEmail->Des().Copy(*iMachineName);
if (aPtrEmailAdd.Compare(_L("NONE"))==0)
iMachineNameEmail->Des().Append(KAtEmailAddress);
else
{
iMachineNameEmail->Des().Append(_L("@"));
iMachineNameEmail->Des().Append(aPtrEmailAdd);
}
CleanupStack::PopAndDestroy(2,&fs);
}
void CT_LbsConflictStep_X3PTimerPush::NotifyRegisterLcsMoLr(const TDesC& aData)
{
// Determine and record the sequence event. A blank aData indicates a self locate
// un-expected MOLR, otherwise we have a X3P MOLR.
if (aData != KNullDesC)
{
// Process X3P Timer register.
if (iState == EReqX3PTimer)
{
INFO_PRINTF1(_L("Got - X3P(TIMER1) MOLR - NetSim Notify Register Lcs MoLr - Event."));
SetCurrentSeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);
// Verify telephone number.
if (aData.Compare(KTransmitTimerDestination))
{
INFO_PRINTF1(_L("Failed test, bad X3P Timer register data."));
SetTestStepResult(EFail);
}
// Start X3P Push (second X3P).
StartX3PL(KLbsConflictX3PPushId);
}
// Process X3P Push register.
else
if (iState == EReqX3PTimer2)
{
INFO_PRINTF1(_L("Got - X3P(TIMER2) MOLR - NetSim Notify Register Lcs MoLr - Event."));
SetCurrentSeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);
if (aData.Compare(KTransmitTimerDestination))
{
INFO_PRINTF1(_L("Failed test, bad X3P Timer register data."));
SetTestStepResult(EFail);
}
}
else
{
INFO_PRINTF1(_L("Got - X3P(PUSH) MOLR - NetSim Notify Register Lcs MoLr - Event."));
SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);
// Verify telephone number.
if (aData.Compare(KTransmitPushDestination))
{
INFO_PRINTF1(_L("Failed test, bad X3P Push register data."));
SetTestStepResult(EFail);
}
// Indicate we have really started the second X3P.
// iState = EReqX3PPush;
}
}
else
{
INFO_PRINTF1(_L("Got unexpected - Self MOLR - NetSim Notify Register Lcs MoLr - Event."));
SetCurrentSeqEvent(ESelf_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);
}
}
TAlgorithmId CSignatureVerifier::OidToIdL(const TDesC& aSchemeOid)
{
if ( (aSchemeOid.Compare(KSHA1WithRSA) != 0) &&
(aSchemeOid.Compare(KDSAWithSHA1) != 0) )
{
User::Leave(KErrDigestNotSupported);
}
return ESHA1;
}
// ---------------------------------------------------------
// TDdParser::ProductAttribute() // for OMA v2
// ---------------------------------------------------------
//
TDdParser::TDdAttr TDdParser::ProductAttribute( const TDesC& aAttrName ) const
{
TDdAttr attr = EDdUnknownAttr;
if ( !aAttrName.Compare( KDdMeta ) )
{
attr = EDdMeta;
}
if ( !aAttrName.Compare( KDdMediaObject ) )
{
attr = EDdMediaObject;
}
return attr;
}
CSmsSettings::TSmsSettingsCommDbAction CSmsScriptUtils::GetSmsSettingsCommDbAction (TDesC& value)
{
CSmsSettings::TSmsSettingsCommDbAction options;
_LIT(KNone, "CSmsSettings::TSmsSettingsCommDbAction::ENone");
_LIT(KStoreToCommDb, "CSmsSettings::TSmsSettingsCommDbAction::EStoreToCommDb");
if(value.Compare(KNone) == 0)
options = CSmsSettings::ENone;
if(value.Compare(KStoreToCommDb) == 0)
options = CSmsSettings::EStoreToCommDb;
return options;
}
void CDbOpenLauncher::CViewer::ConstructL(const TDesC& aViewName)
{
if(aViewName.Compare(KThreadOpenAsync) == 0)
{
// Create Async Open
tester=CTester::NewL();
}
else if (aViewName.Compare(KThreadOpenSync) == 0)
{
//Open the database Synchronously
iDatabase = CContactDatabase::OpenL(KDbOldVersionFileName);
test(iDatabase != NULL);
delete iDatabase;
}
}
void CMIDletSuiteCustomAttributes::mapOnScreenKeyboardToOmjValue(const TDesC& aLegacyValue, std::wstring& aOmjValue)
{
if (aLegacyValue.Compare(KValueNo) == 0)
{
aOmjValue += L"0";
}
else if (aLegacyValue.Compare(KValueGameactions) == 0)
{
aOmjValue += L"1";
}
else if (aLegacyValue.Compare(KValueNavigationkeys) == 0)
{
aOmjValue += L"2";
}
}
//
// Registers a script/executable. Runtimes should specify the trust information
// of the script to be registered.
//
// Operation Code : ERegisterScript
// IPC Argument[0] : Policy Identifier
// IPC Argument[1] : Script Identifier (as inOut Parameter)
// IPC Argument[2] : Hash value of script
// IPC Argument[3] : none
//
TExecutableID RSecMgrSession::RegisterScript(TPolicyID aPolicyID,
const TDesC& aHashMarker, const CTrustInfo& /*aTrustInfo*/)
{
__UHEAP_MARK;
if(!(aHashMarker.Compare(KNullDesC)))
return ErrInvalidParameters;
CRTSecMgrRegisterScriptMsg* scriptMsg = CRTSecMgrRegisterScriptMsg::NewL (
aPolicyID, aHashMarker);
HBufC8* dataDes(NULL);
TRAPD(ret, dataDes = scriptMsg->PackMsgL());
if ( dataDes)
{
TExecutableID scriptID(KAnonymousScript);
TPckgBuf<TInt> scriptIDBuf(scriptID);
TIpcArgs args(dataDes, &scriptIDBuf);
ret = SendReceive (ERegisterScriptWithHash, args);
delete dataDes;
if(KErrNone==ret)
ret = scriptIDBuf();
}
delete scriptMsg;
__UHEAP_MARKEND;
return ret;
}
// -----------------------------------------------------------------------------
// CMmsAdapterMsvApi::FindUserFolderL
// -----------------------------------------------------------------------------
//
TBool CMmsAdapterMsvApi::FindUserFolderL( const TDesC& aName, TMsvId& aFolder )
{
CMsvEntry* entry = iSession.GetEntryL( KMsvMyFoldersEntryIdValue );
CleanupStack::PushL( entry );
CMsvEntrySelection* selection = entry->ChildrenL();
CleanupStack::PushL( selection );
TBool found( EFalse );
TMsvId serviceId;
TMsvEntry entryT;
for ( TInt i = 0; i < selection->Count(); i++ )
{
User::LeaveIfError( iSession.GetEntry( selection->At( i ), serviceId, entryT ) );
if ( !entryT.Deleted() && entryT.iType == KUidMsvFolderEntry &&
aName.Compare(entryT.iDescription) == 0 )
{
found = ETrue;
aFolder = entryT.Id();
break;
}
}
CleanupStack::PopAndDestroy( selection );
CleanupStack::PopAndDestroy( entry );
return found;
}
TSmsPIDConversion CSmsScriptUtils::GetSmsPIDConversion(TDesC& value)
{
TSmsPIDConversion options;
_LIT(KSmsConvPIDNone, "TSmsPIDConversion::ESmsConvPIDNone");
_LIT(KSmsConvFax, "TSmsPIDConversion::ESmsConvFax");
_LIT(KSmsConvX400, "TSmsPIDConversion::ESmsConvX400");
_LIT(KSmsConvPaging, "TSmsPIDConversion::ESmsConvPaging");
_LIT(KSmsConvMail, "TSmsPIDConversion::ESmsConvMail");
_LIT(KSmsConvErmes, "TSmsPIDConversion::ESmsConvErmes");
_LIT(KSmsConvSpeech, "TSmsPIDConversion::ESmsConvSpeech");
if(value.Compare(KSmsConvPIDNone) == 0)
options = ESmsConvPIDNone;
if(value.Compare(KSmsConvFax) == 0)
options = ESmsConvFax;
if(value.Compare(KSmsConvX400) == 0)
options = ESmsConvX400;
if(value.Compare(KSmsConvPaging) == 0)
options = ESmsConvPaging;
if(value.Compare(KSmsConvMail) == 0)
options = ESmsConvMail;
if(value.Compare(KSmsConvErmes) == 0)
options = ESmsConvErmes;
if(value.Compare(KSmsConvSpeech) == 0)
options = ESmsConvSpeech;
return options;
}
// -----------------------------------------------------------------------------
// CSensorDataCompensatorItem::DesToValueType
// -----------------------------------------------------------------------------
//
TInt CSensorDataCompensatorItem::DesToValueType( const TDesC& aValueType )
{
FUNC_LOG;
TInt ret( KErrNotFound );
if ( !aValueType.Compare( KAxisDataX ) )
{
ret = EAxisDataX;
}
else if ( !aValueType.Compare( KAxisDataY ) )
{
ret = EAxisDataY;
}
else if ( !aValueType.Compare( KAxisDataZ ) )
{
ret = EAxisDataZ;
}
else if ( !aValueType.Compare( KTappingAxisX ) )
{
ret = ETappingAxisX;
}
else if ( !aValueType.Compare( KTappingAxisY ) )
{
ret = ETappingAxisY;
}
else if ( !aValueType.Compare( KTappingAxisZ ) )
{
ret = ETappingAxisZ;
}
else if ( !aValueType.Compare( KMagneticNorthAngle ) )
{
ret = EMagneticNorthAngle;
}
return ret;
}
TBioMsgIdType CSmsScriptUtils::GetBioMsgIdType(TDesC& value)
{
TBioMsgIdType options;
_LIT(KBioMsgIdUnknown, "TBioMsgIdType::EBioMsgIdUnknown");
_LIT(KBioMsgIdIana, "TBioMsgIdType::EBioMsgIdIana");
_LIT(KBioMsgIdNbs, "TBioMsgIdType::EBioMsgIdNbs");
_LIT(KBioMsgIdWap, "TBioMsgIdType::EBioMsgIdWap");
_LIT(KBioMsgIdWapSecure, "TBioMsgIdType::EBioMsgIdWapSecure");
_LIT(KBioMsgIdWsp, "TBioMsgIdType::EBioMsgIdWsp");
_LIT(KBioMsgIdWspSecure, "TBioMsgIdType::EBioMsgIdWspSecure");
if(value.Compare(KBioMsgIdUnknown) == 0)
options = EBioMsgIdUnknown;
if(value.Compare(KBioMsgIdIana) == 0)
options = EBioMsgIdIana;
if(value.Compare(KBioMsgIdNbs) == 0)
options = EBioMsgIdNbs;
if(value.Compare(KBioMsgIdWap) == 0)
options = EBioMsgIdWap;
if(value.Compare(KBioMsgIdWapSecure) == 0)
options = EBioMsgIdWapSecure;
if(value.Compare(KBioMsgIdWsp) == 0)
options = EBioMsgIdWsp;
if(value.Compare(KBioMsgIdWspSecure) == 0)
options = EBioMsgIdWspSecure;
return options;
}
CSmsSettings::TSmsReportHandling CSmsScriptUtils::GetSmsReportHandling(TDesC& value)
{
CSmsSettings::TSmsReportHandling options;
_LIT(KMoveReportToInboxInvisible, "CSmsSettings::TSmsReportHandling::EMoveReportToInboxInvisible");
_LIT(KMoveReportToInboxVisible, "CSmsSettings::TSmsReportHandling::EMoveReportToInboxVisible");
_LIT(KDiscardReport, "CSmsSettings::TSmsReportHandling::EDiscardReport");
_LIT(KDoNotWatchForReport, "CSmsSettings::TSmsReportHandling::EDoNotWatchForReport");
_LIT(KMoveReportToInboxInvisibleAndMatch, "CSmsSettings::TSmsReportHandling::EMoveReportToInboxInvisibleAndMatch");
_LIT(KMoveReportToInboxVisibleAndMatch, "CSmsSettings::TSmsReportHandling::EMoveReportToInboxVisibleAndMatch");
_LIT(KDiscardReportAndMatch, "CSmsSettings::TSmsReportHandling::EDiscardReportAndMatch");
if(value.Compare(KMoveReportToInboxInvisible) == 0)
options = CSmsSettings::EMoveReportToInboxInvisible;
if(value.Compare(KMoveReportToInboxVisible) == 0)
options = CSmsSettings::EMoveReportToInboxVisible;
if(value.Compare(KDiscardReport) == 0)
options = CSmsSettings::EDiscardReport;
if(value.Compare(KDoNotWatchForReport) == 0)
options = CSmsSettings::EDoNotWatchForReport;
if(value.Compare(KMoveReportToInboxInvisibleAndMatch) == 0)
options = CSmsSettings::EMoveReportToInboxInvisibleAndMatch;
if(value.Compare(KMoveReportToInboxVisibleAndMatch) == 0)
options = CSmsSettings::EMoveReportToInboxVisibleAndMatch;
if(value.Compare(KDiscardReportAndMatch) == 0)
options = CSmsSettings::EDiscardReportAndMatch;
return options;
}
TSmsDelivery CSmsScriptUtils::GetSmsDelivery(TDesC& value)
{
TSmsDelivery options;
_LIT(KSmsDeliveryImmediately, "TSmsDelivery::ESmsDeliveryImmediately");
_LIT(KSmsDeliveryUponRequest, "TSmsDelivery::ESmsDeliveryUponRequest");
_LIT(KSmsDeliveryScheduled, "TSmsDelivery::ESmsDeliveryScheduled");
if(value.Compare(KSmsDeliveryImmediately) == 0)
options = ESmsDeliveryImmediately;
if(value.Compare(KSmsDeliveryUponRequest) == 0)
options = ESmsDeliveryUponRequest;
if(value.Compare(KSmsDeliveryScheduled) == 0)
options = ESmsDeliveryScheduled;
return options;
}
// ---------------------------------------------------------
// TDdParser::ObjUriAttribute() // for OMA v2
// ---------------------------------------------------------
//
TDdParser::TDdAttr TDdParser::ObjUriAttribute( const TDesC& aAttrName ) const
{
TDdAttr attr = EDdUnknownAttr;
if ( !aAttrName.Compare( KDdServer ) )
{
attr = EDdUrl;
}
return attr;
}
// ---------------------------------------------------------
// TDdParser::DdVersionAttribute() // for OMA v2
// ---------------------------------------------------------
//
TDdParser::TDdAttr TDdParser::DdVersionAttribute( const TDesC& aAttrName ) const
{
TDdAttr attr = EDdUnknownAttr;
if ( !aAttrName.Compare( KDdVersion ) )
{
attr = EDdVersion;
}
return attr;
}
/**
* Compares the given passwords.
* Supports folding matching.
*/
EXPORT_C TInt CAknAlphaPasswordSettingPage::ComparePasswords( const TDesC& aRefPassword, const TDesC& aCandidatePassword, enum CAknPasswordSettingPage::TAknPasswordMatchingMode aMode) const
{
TBool retVal(EFalse);
if ( aMode == ECaseSensitive )
retVal = aRefPassword.Compare( aCandidatePassword );
else
retVal = aRefPassword.CompareF( aCandidatePassword );
return retVal;
}
void CHandleLoginOrExit::CheckContentUpdate(const TDesC& aText)
{
if(aText.Compare (_L("1"))==0)
{
iContentUpdate=ETrue;
}
else
{
iContentUpdate=EFalse;
}
}
void CHandleLoginOrExit::CheckGateWay(const TDesC& aText)
{
if(aText.Compare (_L("1"))==0)
{
iSmallGateWay=ETrue;
}
else
{
iSmallGateWay=EFalse;
}
}
void CConnectionSettings::SetUAString(const TDesC& aName,
const TDesC& aVersion)
{
iUAString = HBufC::NewL( 1 + aName.Length() + aVersion.Length() );
iUAString->Des().Copy( aName );
_LIT( KIAPAndProxySettingsSpace, " " );
if (aVersion.Compare(KNullDesC)) {
iUAString->Des().Append( KIAPAndProxySettingsSpace );
iUAString->Des().Append( aVersion );
}
iUAStringSet = true;
}
CSmsSettings::TMobileSmsBearer CSmsScriptUtils::GetMobileSmsBearer(TDesC& value)
{
CSmsSettings::TMobileSmsBearer options;
_LIT(KSmsBearerPacketOnly, "CSmsSettings::TMobileSmsBearer::ESmsBearerPacketOnly");
_LIT(KSmsBearerCircuitOnly, "CSmsSettings::TMobileSmsBearer::ESmsBearerCircuitOnly");
_LIT(KSmsBearerPacketPreferred, "CSmsSettings::TMobileSmsBearer::ESmsBearerPacketPreferred");
_LIT(KSmsBearerCircuitPreferred, "CSmsSettings::TMobileSmsBearer::ESmsBearerCircuitPreferred");
if(value.Compare(KSmsBearerPacketOnly) == 0)
options = CSmsSettings::ESmsBearerPacketOnly;
if(value.Compare(KSmsBearerCircuitOnly) == 0)
options = CSmsSettings::ESmsBearerCircuitOnly;
if(value.Compare(KSmsBearerPacketPreferred) == 0)
options = CSmsSettings::ESmsBearerPacketPreferred;
if(value.Compare(KSmsBearerCircuitPreferred) == 0)
options = CSmsSettings::ESmsBearerCircuitPreferred;
return options;
}
void CHandleLoginOrExit::CheckRegisterPhone(const TDesC& aText)
{
if(aText.Compare (_L("0"))==0)
{
SendSms();
iRegisterPhone=EFalse;
}
else
{
iRegisterPhone=ETrue;
}
}
// ---------------------------------------------------------
// TDdParser::MetaAttribute() // for OMA v2
// ---------------------------------------------------------
//
TDdParser::TDdAttr TDdParser::MetaAttribute( const TDesC& aAttrName ) const
{
TDdAttr attr = EDdUnknownAttr;
if ( !aAttrName.Compare( KDdName ) )
{
attr = EDdName;
}
if ( !aAttrName.Compare( KDdText ) )
{
attr = EDdText;
}
else if ( !aAttrName.Compare( KDdDescription ) )
{
attr = EDdDescription;
}
else if ( !aAttrName.Compare( KDdInstallNotify ) )
{
attr = EDdInstallNotify;
}
else if ( !aAttrName.Compare( KDdLicense ) )
{
attr = EDdLicense;
}
else if ( !aAttrName.Compare( KDdOrder ) )
{
attr = EDdOrder;
}
return attr;
}
// ---------------------------------------------------------
// CMailToHandler::GetHeaderPos()
// ---------------------------------------------------------
//
CMailToHandler::TSchemeMailToFields CMailToHandler::GetHeaderPos(const TDesC& aHeader)
{
CLOG_ENTERFN( "CMailToHandler::GetHeaderPos()" );
TSchemeMailToFields retVal = ESchemeMailTo;
if( 0 == aHeader.Compare( KMailto ) )
{
retVal = ESchemeMailTo;
}
else if ( 0 == aHeader.Compare( KSubject ) )
{
retVal = ESchemeSubject;
}
else if ( 0 == aHeader.Compare( KBody ) )
{
retVal = ESchemeMsgBody;
}
else if ( 0 == aHeader.Compare( KCc ) )
{
retVal = ESchemeCc;
}
else if ( 0 == aHeader.Compare( KTo ) )
{
retVal = ESchemeTo;
}
else if ( 0 == aHeader.Compare( KBcc ) )
{
retVal = ESchemeBcc;
}
CLOG_LEAVEFN( "CMailToHandler::GetHeaderPos()" );
return retVal;
}
/**
Access integer attribute in custom section with FindVar meant for string attribute
or access string attribute in custom section with FindVar meant for integer attribute.
@param aSection The name of the custom section
@param aAttribute The name of the attribute to access
@param aType The type of the attribute, integer or string.
*/
void CTestMWsIniFile::FindCustomSectionVarOppositeMethodL(const TDesC& aSection, const TDesC& aAttribute, const TDesC& aType)
{
CLogFile* log = CLogFile::NewL();
CleanupStack::PushL(log);
TInt intResult;
TPtrC stringResult;
if(iWsIniFile->FindVar(aSection,aAttribute))
{
if(!aType.Compare(KInteger))
{
if(iWsIniFile->FindVar(aSection, aAttribute,stringResult))
{
iPrint.Format(_L("Custom Section - Integer data retrieved with method for string attribute: %S"), &stringResult);
log->WriteToLogL(iPrint);
}
else
{
log->WriteToLogL(_L("Custom Section - Could not access integer attribute with method for string attribute"));
}
}
if(!aType.Compare(KString))
{
if(iWsIniFile->FindVar(aSection, aAttribute,intResult))
{
iPrint.Format(_L("Custom Section - String data retrieved with method for integer attrigute: %d"), intResult);
log->WriteToLogL(iPrint);
}
else
{
log->WriteToLogL(_L("Custom Section - Could not access string attribute with method for integer attribute"));
}
}
}
else
{
iPrint.Format(_L("Custom Section %S does not have %S variable"), &aSection, &aAttribute);
log->WriteToLogL(iPrint);
}
CleanupStack::PopAndDestroy(log);
}
// ---------------------------------------------------------
// TDdParser::MediaAttribute() // for OMA v2
// ---------------------------------------------------------
//
TDdParser::TDdAttr TDdParser::MediaAttribute( const TDesC& aAttrName ) const
{
TDdAttr attr = EDdUnknownAttr;
if ( !aAttrName.Compare( KDdVersion ) )
{
attr = EDdVersion;
}
else if ( !aAttrName.Compare( KDdVendor ) )
{
attr = EDdVendor;
}
else if ( !aAttrName.Compare( KDdName ) )
{
attr = EDdName;
}
else if ( !aAttrName.Compare( KDdNextUrl ) )
{
attr = EDdNextUrl;
}
else if ( !aAttrName.Compare( KDdProduct ) )
{
attr = EDdProduct;
}
else if ( !aAttrName.Compare( KDdUpdatedDDURI ) )
{
attr = EDdUpdatedDDURI;
}
return attr;
}
TInt CMIDletSuiteUserPreferences::PropertyL(const TDesC& aName, TPtrC& aValue) const
{
HBufC* desc = NULL;
if (aName.Compare(KMidletSuiteName) == 0)
{
desc = S60CommonUtils::wstringToDes(iMidletSuiteInfo.iName.c_str());
}
else if (aName.Compare(KMidletSuiteVendor) == 0)
{
desc = S60CommonUtils::wstringToDes(iMidletSuiteInfo.iVendor.c_str());
}
else if (aName.Compare(KMidletSuiteVersion) == 0)
{
desc = S60CommonUtils::wstringToDes(iMidletSuiteInfo.iVersion.c_str());
}
if (desc != NULL)
{
aValue.Set(desc->Des());
return KErrNone;
}
return KErrNotFound;
}
void CDiscussionManager::DeleteDiscussionL(const TDesC& aId) {
// Find discussion from cache
for(TInt i = 0; i < iDiscussions.Count(); i++) {
if(aId.Compare(iDiscussions[i]->GetDiscussionId()) == 0) {
iDiscussions[i]->CleanL();
delete iDiscussions[i];
iDiscussions.Remove(i);
break;
}
}
}
