Beispiel #1
0
// ---------------------------------------------------------
// 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;
	}
Beispiel #6
0
// ---------------------------------------------------------
// 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;
	}
Beispiel #8
0
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;
	}
Beispiel #17
0
// ---------------------------------------------------------
// TDdParser::ObjUriAttribute() // for OMA v2
// ---------------------------------------------------------
//
TDdParser::TDdAttr TDdParser::ObjUriAttribute( const TDesC& aAttrName ) const
    {
    TDdAttr attr = EDdUnknownAttr;

	if ( !aAttrName.Compare( KDdServer ) )
        {
        attr = EDdUrl;
        }
    return attr;
    }
Beispiel #18
0
// ---------------------------------------------------------
// 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;
	}
}
Beispiel #25
0
// ---------------------------------------------------------
// 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);
	}
Beispiel #28
0
// ---------------------------------------------------------
// 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;
		}
	}
}