diff -r b9b00b134b0d -r d316aecb87fd applicationmanagement/options/src/AMInstallOptions.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/applicationmanagement/options/src/AMInstallOptions.cpp Tue Jul 13 04:01:20 2010 +0530 @@ -0,0 +1,927 @@ +/* +* Copyright (c) 2000 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: ApplicationManagementOptions implementation +* +*/ + + + +#include +#include +#include "debug.h" +#include "aminstalloptions.h" +#include "aminstalloptionsint.h" + + +namespace AMXml + { + + struct TLangCodeMapping + { + //const TText8 *const iCode ; + const TText8 * iCode ; + TLanguage iLang ; + }; + + // Language options + const TLangCodeMapping KLangOptions[] = + { + {_S8("EN"), ELangEnglish}, + {_S8("FR"), ELangFrench}, + {_S8("GE"), ELangGerman}, + {_S8("SP"), ELangSpanish}, + {_S8("IT"), ELangItalian}, + {_S8("SW"), ELangSwedish}, + {_S8("DA"), ELangDanish}, + {_S8("NO"), ELangNorwegian}, + {_S8("FI"), ELangFinnish}, + {_S8("AM"), ELangAmerican}, + {_S8("SF"), ELangSwissFrench}, + {_S8("SG"), ELangSwissGerman}, + {_S8("PO"), ELangPortuguese}, + {_S8("TU"), ELangTurkish}, + {_S8("IC"), ELangIcelandic}, + {_S8("RU"), ELangRussian}, + {_S8("HU"), ELangHungarian}, + {_S8("DU"), ELangDutch}, + {_S8("BL"), ELangBelgianFlemish}, + {_S8("AU"), ELangAustralian}, + {_S8("BF"), ELangBelgianFrench}, + {_S8("AS"), ELangAustrian}, + {_S8("NZ"), ELangNewZealand}, + {_S8("IF"), ELangInternationalFrench}, + {_S8("CS"), ELangCzech}, + {_S8("SK"), ELangSlovak}, + {_S8("PL"), ELangPolish}, + {_S8("SL"), ELangSlovenian}, + {_S8("TC"), ELangTaiwanChinese}, + {_S8("HK"), ELangHongKongChinese}, + {_S8("ZH"), ELangPrcChinese}, + {_S8("JA"), ELangJapanese}, + {_S8("TH"), ELangThai}, + {_S8("AF"), ELangAfrikaans }, + {_S8("SQ"), ELangAlbanian }, + {_S8("AH"), ELangAmharic }, + {_S8("AR"), ELangArabic }, + {_S8("HY"), ELangArmenian }, + {_S8("TL"), ELangTagalog }, + {_S8("BE"), ELangBelarussian }, + {_S8("BN"), ELangBengali }, + {_S8("BG"), ELangBulgarian }, + {_S8("MY"), ELangBurmese }, + {_S8("CA"), ELangCatalan }, + {_S8("HR"), ELangCroatian }, + {_S8("CE"), ELangCanadianEnglish }, + {_S8("IE"), ELangInternationalEnglish }, + {_S8("SF"), ELangSouthAfricanEnglish }, + {_S8("ET"), ELangEstonian }, + {_S8("FA"), ELangFarsi }, + {_S8("CF"), ELangCanadianFrench }, + {_S8("GD"), ELangScotsGaelic }, + {_S8("KA"), ELangGeorgian }, + {_S8("EL"), ELangGreek }, + {_S8("CG"), ELangCyprusGreek }, + {_S8("GU"), ELangGujarati }, + {_S8("HE"), ELangHebrew }, + {_S8("HI"), ELangHindi }, + {_S8("IN"), ELangIndonesian }, + {_S8("GA"), ELangIrish }, + {_S8("SZ"), ELangSwissItalian }, + {_S8("KN"), ELangKannada }, + {_S8("KK"), ELangKazakh }, + {_S8("KM"), ELangKhmer }, + {_S8("KO"), ELangKorean }, + {_S8("LO"), ELangLao }, + {_S8("LV"), ELangLatvian }, + {_S8("LT"), ELangLithuanian }, + {_S8("MK"), ELangMacedonian }, + {_S8("MS"), ELangMalay }, + {_S8("ML"), ELangMalayalam }, + {_S8("MR"), ELangMarathi }, + {_S8("MO"), ELangMoldavian }, + {_S8("MN"), ELangMongolian }, + {_S8("NN"), ELangNorwegianNynorsk }, + {_S8("BP"), ELangBrazilianPortuguese }, + {_S8("PA"), ELangPunjabi }, + {_S8("RO"), ELangRomanian }, + {_S8("SR"), ELangSerbian }, + {_S8("SI"), ELangSinhalese }, + {_S8("SO"), ELangSomali }, + {_S8("OS"), ELangInternationalSpanish }, + {_S8("LS"), ELangLatinAmericanSpanish }, + {_S8("SH"), ELangSwahili }, + {_S8("FS"), ELangFinlandSwedish }, + //{_S8("??"), ELangReserved1 }, + {_S8("TA"), ELangTamil }, + {_S8("TE"), ELangTelugu }, + {_S8("BO"), ELangTibetan }, + {_S8("TI"), ELangTigrinya }, + {_S8("CT"), ELangCyprusTurkish }, + {_S8("TK"), ELangTurkmen }, + {_S8("UK"), ELangUkrainian }, + {_S8("UR"), ELangUrdu }, + //{_S8("??"), ELangReserved2 }, + {_S8("VI"), ELangVietnamese }, + {_S8("CY"), ELangWelsh }, + {_S8("ZU"), ELangZulu }, + //{_S8("??"), ELangOther }, + //{_S8("??"), ELangNone } + }; + + const TInt KNumLangOptions = (sizeof(KLangOptions)/sizeof(TLangCodeMapping)); + + // boolean "value" attribute values + _LIT8( KIOValueTrue, "yes" ); + _LIT8( KIOValueFalse, "no" ); + // notimp _LIT8( KIOAsk, "askuser" ); + + _LIT8( KIODefaultLanguage, "*"); + + // notimp _LIT8( KIOMissingOptionPolicyValDefault, "usedefault" ); + _LIT8( KIOMissingOptionPolicyValFail, "fail" ); + // notimp _LIT8( KIOMissingOptionPolicyValAsk, "askuser" ); + + // "Name" attribute values + _LIT8( KIODrive, "drive" ); + _LIT8( KIOLanguage, "lang" ); + _LIT8( KIOUpgrade, "upgrade" ); + _LIT8( KIOKill, "kill" ); + + // sym specific + _LIT8( KIOCapabilities, "capabilities" ); + _LIT8( KIOUntrusted, "untrusted" ); + _LIT8( KIOPkginfo, "pkginfo" ); + _LIT8( KIOOptionalItems, "optionals" ); + + _LIT8 ( KIOOCSP, "ocsp" ); + _LIT8 ( KIOOCSPWarning, "ignoreocspwarn" ); + _LIT8 ( KIOOverwrite, "fileoverwrite" ); + + _LIT8 ( KIOUpgradeData, "upgradedata" ); // iUpgradeData + + _LIT8( KUIOBreakDependency, "allowdependencybreak" ); + + _LIT8( KIOAttrNameDefaultPolicy, "missingoptionpolicy" ); + + _LIT8( KIODownload, "download" ); + _LIT8( KIOHttpUsername, "httpusername" ); + _LIT8( KIOHttpPassword, "httppassword" ); + _LIT8( KIOIAP, "conref" ); + + namespace Reader + { + // XML node names + _LIT8( KIOStartElement, "InstOpts") ; + _LIT8( KIOStdOpt, "StdOpt"); + _LIT8( KIOStdSymOpt, "StdSymOpt" ); + _LIT8( KIOCustSymOpts, "CustSymOpts" ); + // notimp _LIT8( KIOOpt, "Opt" ); + + // Xml attribute names + // notimp _LIT8( KIOOptAttrIndex, "index" ); + _LIT8( KIOAttrName, "name" ); + _LIT8( KIOAttrValue, "value" ); + + } + + namespace Writer + { + _LIT8( KIOStartElement, "") ; + _LIT8( KIOStdOptFormat, "" ); + _LIT8( KIOStdSymOptFormat, "" ); + // notimp _LIT8( KIOCustSymOptsStartFormat, "" ); + // notimp _LIT8( KIOCustSymOptsEnd, "" ); + // notimp _LIT8( KIOOptFormat, "" ); + _LIT8( KIOStartElementEnd, "") ; + + _LIT8( KUIOStartElement, "" ); + _LIT8( KUIOStartElementEnd, "" ); + } + } + +/////////////////////////////////////////////////// +// +// CAMInstOptsParserBase +// +/////////////////////////////////////////////////// + + +CAMInstOptsParserBase::~CAMInstOptsParserBase() + { + delete iParser; + iParser = NULL; + } + +void CAMInstOptsParserBase::SetPolicyValue( SwiUI::TPolicy &aPolicy, const TDesC8& aValue ) const + { + using namespace AMXml; + + if ( aValue == KIOValueTrue ) + { + aPolicy = SwiUI::EPolicyAllowed ; + } + else if ( aValue == KIOValueFalse ) + { + aPolicy = SwiUI::EPolicyNotAllowed ; + } + else + { + aPolicy = iDefaultPolicy; + } + } +void CAMInstOptsParserBase::ConstructL() + { + iParser = Xml::CParser::NewL( _L8( "text/xml"), *this ); + + } + +void CAMInstOptsParserBase::ParseL() + { + Xml::ParseL( *iParser, iBuffer ); + } + +void CAMInstOptsParserBase::OnStartElementL(const Xml::RTagInfo& /*aElement*/, + const Xml::RAttributeArray& /*aAttributes*/, TInt aErrorCode) + { + RDEBUG("CAMInstOptsParserBase::OnStartElementL"); + if( aErrorCode != KErrNone ) + { + RDEBUG_2( " ->OnStartElementL (aErrorCode '%d')", aErrorCode ); + } + } + +void CAMInstOptsParserBase::OnEndDocumentL(TInt aErrorCode) + { + RDEBUG("CAMInstOptsParserBase::OnEndDocumentL"); + if( aErrorCode != KErrNone ) + { + RDEBUG_2( " ->OnEndDocumentL (aErrorCode '%d')", aErrorCode ); + } + } + +void CAMInstOptsParserBase::OnStartDocumentL(const Xml::RDocumentParameters& aDocParam, TInt aErrorCode) + { + RDEBUG("CAMInstOptsParserBase::OnStartDocumentL"); + if( aErrorCode != KErrNone ) + { + const TDesC8 &d = aDocParam.CharacterSetName().DesC(); + RDEBUG8_3( " ->OnStartDocumentL (aDocParam '%S', aErrorCode %d)" , + &d,aErrorCode ); + } + } + +void CAMInstOptsParserBase::OnEndElementL(const Xml::RTagInfo& aElement, TInt aErrorCode) + { + RDEBUG("CAMInstOptsParserBase::OnEndElementL"); + if( aErrorCode != KErrNone ) + { + const TDesC8 &d = aElement.LocalName().DesC(); + RDEBUG8_3( " ->OnEndElementL (LocalName '%S', aErrorCode %d)", + &d,aErrorCode ); + } + } + +void CAMInstOptsParserBase::OnContentL( + #ifdef _DEBUG + const TDesC8& aBytes + #else + const TDesC8& /*aBytes*/ + #endif + ,TInt aErrorCode ) + { + RDEBUG("CAMInstOptsParserBase::OnContentL"); + if( aErrorCode != KErrNone ) + { + #ifdef _DEBUG + RDEBUG8_3( " ->OnContentL (abytes '%S', aErrorCode %d)", + &aBytes, aErrorCode ); + #else + RDEBUG8_2( " ->OnContentL (aErrorCode %d)", aErrorCode ); + #endif + } + + } +void CAMInstOptsParserBase::OnStartPrefixMappingL(const RString& /*aPrefix*/, + const RString& /*aUri*/, TInt /*aErrorCode*/) + { + + } +void CAMInstOptsParserBase::OnEndPrefixMappingL(const RString& /*aPrefix*/, TInt /*aErrorCode*/) + { + + } +void CAMInstOptsParserBase::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/) + { + + } +void CAMInstOptsParserBase::OnSkippedEntityL(const RString& /*aName*/, TInt /*aErrorCode*/) + { + + } +void CAMInstOptsParserBase::OnProcessingInstructionL(const TDesC8& /*aTarget*/, + const TDesC8& /*aData*/, TInt /*aErrorCode*/) + { + + } +void CAMInstOptsParserBase::OnError(TInt aErrorCode) + { + RDEBUG("CAMInstOptsParserBase::OnError"); + if( aErrorCode != KErrNone ) + { + RDEBUG_2( " ->OnError ( aErrorCode %d)",aErrorCode ); + } + } + + + +TAny* CAMInstOptsParserBase::GetExtendedInterface(const TInt32 /*aUid*/) + { + + return NULL; + } + + +/////////////////////////////////////////////////// +// +// CAMInstOptsParser +// +/////////////////////////////////////////////////// + +CAMInstOptsParser * CAMInstOptsParser::NewLC( const TDesC8 &aBuffer, NApplicationManagement::TAMInstallOptions &aResult ) + { + CAMInstOptsParser *self = new ( ELeave ) CAMInstOptsParser( aBuffer, aResult ); + CleanupStack::PushL( self ); + self->ConstructL() ; + return self ; + } + +CAMInstOptsParser *CAMInstOptsParser::NewL( const TDesC8 &aBuffer, + NApplicationManagement::TAMInstallOptions &aResult ) + { + CAMInstOptsParser *self = NewLC ( aBuffer, aResult ); + CleanupStack::Pop( self ); + return self ; + } + +CAMUninstOptsParser * CAMUninstOptsParser::NewLC( const TDesC8 &aBuffer, SwiUI::TUninstallOptions &aResult ) + { + CAMUninstOptsParser *self = new ( ELeave ) CAMUninstOptsParser( aBuffer, aResult ); + CleanupStack::PushL( self ); + self->ConstructL() ; + return self ; + } + +CAMUninstOptsParser *CAMUninstOptsParser::NewL( const TDesC8 &aBuffer, + SwiUI::TUninstallOptions &aResult ) + { + CAMUninstOptsParser *self = NewLC ( aBuffer, aResult ); + CleanupStack::Pop( self ); + return self ; + } + + +CAMInstOptsParser::~CAMInstOptsParser() + { + + } + + +void CAMInstOptsParser::OnStartElementL(const Xml::RTagInfo& aElement, + const Xml::RAttributeArray& aAttributes, + #ifdef _DEBUG + TInt aErrorCode + #else + TInt /*aErrorCode*/ + #endif + ) + { + +#ifdef _DEBUG + RDEBUG8_3( "CAMInstOptsParser::OnStartElementL (LocalName '%S', aErrorCode %d)", + &aElement.LocalName().DesC(),aErrorCode ); + TInt count2( aAttributes.Count() ); + for( TInt i( 0 ); i < count2; i++ ) + { + RDEBUG8_5( " Attribute %d, type=%d, '%S'='%S' ",i,aAttributes[i].Type(), + &aAttributes[i].Value().DesC(), &aAttributes[i].Attribute().LocalName().DesC() ); + + } +#endif + + using namespace AMXml; + + + const TPtrC8 name( aElement.LocalName().DesC() ); + if ( name == Reader::KIOStartElement ) + { + + if ( aAttributes.Count() == 1 ) + { + TPtrC8 attrname( aAttributes[0].Attribute().LocalName().DesC() ); + if ( attrname == KIOAttrNameDefaultPolicy) + { + + using namespace SwiUI; + TPtrC8 attrval( aAttributes[0].Value().DesC() ); + if ( attrval == KIOMissingOptionPolicyValFail) + { + iDefaultPolicy = EPolicyNotAllowed; + } + else + { + iDefaultPolicy = EPolicyUserConfirm; + } + } + } + } + else if ( name != Reader::KIOCustSymOpts ) + { + RDEBUG8_2( " Processing element '%S'", &name ); + TInt c( aAttributes.Count() ); + if ( c == 2 ) + { + TPtrC8 attrname( aAttributes[0].Attribute().LocalName().DesC() ); + TPtrC8 attrnameval( aAttributes[0].Value().DesC() ); + TPtrC8 attrval( aAttributes[1].Attribute().LocalName().DesC() ); + TPtrC8 attrvalval( aAttributes[1].Value().DesC() ); + RDEBUG8_5( " Name '%S'='%S' Val '%S'='%S' ",&attrname, &attrnameval, + &attrval, &attrvalval ); + if ( attrname == Reader::KIOAttrName ) + { + if ( attrval == Reader::KIOAttrValue ) + { + if ( name == Reader::KIOStdOpt ) + { + if ( attrnameval == KIODrive ) + { + TInt len = attrvalval.Length(); + if (len == 0) + { + TChar KDefaultDrive = 'c'; + iResult.iOptions.iDrive = KDefaultDrive; + //RDEBUG8_2( " Set drive to %c ", iResult.iOptions.iDrive ); + } + else + { + RDEBUG8_2( " Setting drive to %c ", attrvalval[0] ); + iResult.iOptions.iDrive = attrvalval[0]; + } + } + else if ( attrnameval == KIOLanguage ) + { + if ( attrvalval == KIODefaultLanguage ) + { + iResult.iOptions.iUsePhoneLang = ETrue; + } + else + { + for( TInt i( 0 ); i < KNumLangOptions; i++ ) + { + if ( attrvalval == TPtrC8( KLangOptions[i].iCode ) ) + { + #ifdef _DEBUG + TPtrC8 code( KLangOptions[i].iCode ); + RDEBUG8_2( " OnStartElementL : Found language %S", &code); + #endif + iResult.iOptions.iLang = KLangOptions[i].iLang; + break; + } + } + } + + } + else if ( attrnameval == KIOUpgrade ) + { + RDEBUG8_2( " Setting Upgrade to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iUpgrade, attrvalval ); + } + else if ( attrnameval == KIOKill ) + { + RDEBUG8_2( " Setting iKillApp to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iKillApp, attrvalval ); + } + else if ( attrnameval == KIOHttpUsername ) + { + RDEBUG8_2( " Setting iLogin to %S ", &attrvalval ); + iResult.iOptions.iLogin.Copy( attrvalval.Left( SwiUI::KSWInstMaxUserNameLength ) ); + } + else if ( attrnameval == KIOHttpPassword ) + { + RDEBUG8_2( " Setting iPassword to %S ", &attrvalval ); + iResult.iOptions.iPassword.Copy( attrvalval.Left( SwiUI::KSWInstMaxPasswordLength ) ); + } + else if ( attrnameval == KIODownload ) + { + RDEBUG8_2( " Setting iDownload to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iDownload, attrvalval ); + } + else if ( attrnameval == KIOIAP ) + { + RDEBUG8_2( " Setting iConRef to %S ", &attrvalval ); + iResult.iConRef = attrvalval; + + + } + /* + _LIT8( KIOIAP, "iap" ); +*/ + + else + { + RDEBUG8_3( " WARNING Unsupported name attribute value: '%S' for '%S' ", &attrnameval, &name ); + } + } + else if ( name == Reader::KIOStdSymOpt ) + { + if ( attrnameval == KIOCapabilities ) + { + RDEBUG8_2( " Setting iCapabilities to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iCapabilities, attrvalval ); + } + else if ( attrnameval == KIOUntrusted ) + { + RDEBUG8_2( " Setting iUntrusted to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iUntrusted, attrvalval ); + } + else if ( attrnameval == KIOPkginfo ) + { + RDEBUG8_2( " Setting iPackageInfo to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iPackageInfo, attrvalval ); + } + else if ( attrnameval == KIOOCSP ) + { + RDEBUG8_2( " Setting iOCSP to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iOCSP, attrvalval ); + } + else if ( attrnameval == KIOOCSPWarning ) + { + RDEBUG8_2( " Setting iIgnoreOCSPWarnings to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iIgnoreOCSPWarnings, attrvalval ); + } + else if ( attrnameval == KIOOptionalItems ) + { + RDEBUG8_2( " Setting iOptionalItems to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iOptionalItems, attrvalval ); + } + else if ( attrnameval == KIOOverwrite ) + { + RDEBUG8_2( " Setting iOverwrite to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iOverwrite, attrvalval ); + } + else if ( attrnameval == KIOUpgradeData ) + { + RDEBUG8_2( " Setting iUpgradeData to %S ", &attrvalval ); + SetPolicyValue( iResult.iOptions.iUpgradeData, attrvalval ); + } + + else + { + RDEBUG8_3( " WARNING Unsupported name sym attribute value: '%S' for '%S' ", &attrnameval, &name ); + } + } + else + { + RDEBUG("WARNING, unsupported name attribute!"); + } + } + else + { + RDEBUG8_3( " ERROR invalid second attribute!: '%S', expteced: '%S' ", &attrval, &Reader::KIOAttrValue() ); + } + } + else + { + RDEBUG8_3( " ERROR invalid first attribute!: '%S', expteced: '%S' ", &attrname, &Reader::KIOAttrName() ); + } + } + else + { + RDEBUG8_3( " ERROR unsupported count of attributes!!: '%d' for '%S' ", c, &name); + } + } + else + { + RDEBUG( " ERROR custom options not implemented!!!!" ); + + } + } + + +/////////////////////////////////////////////////// +// +// CAMUninstOptsParser +// +/////////////////////////////////////////////////// + +CAMUninstOptsParser::~CAMUninstOptsParser() + { + + } + +void CAMUninstOptsParser::OnStartElementL(const Xml::RTagInfo& aElement, + const Xml::RAttributeArray& aAttributes, + #ifdef _DEBUG + TInt aErrorCode + #else + TInt /*aErrorCode*/ + #endif + ) + { + +#ifdef _DEBUG + RDEBUG8_3( "CAMUninstOptsParser::OnStartElementL (LocalName '%S', aErrorCode %d)", + &aElement.LocalName().DesC(),aErrorCode ); + TInt count2( aAttributes.Count() ); + for( TInt i( 0 ); i < count2; i++ ) + { + RDEBUG8_5( " Attribute %d, type=%d, '%S'='%S' ",i,aAttributes[i].Type(), + &aAttributes[i].Value().DesC(), &aAttributes[i].Attribute().LocalName().DesC() ); + + } +#endif + + using namespace AMXml; + + + const TPtrC8 name( aElement.LocalName().DesC() ); + if ( name == Reader::KIOStartElement ) + { + + } + else if ( name != Reader::KIOCustSymOpts ) + { + RDEBUG8_2( " Processing element '%S'", &name ); + TInt c( aAttributes.Count() ); + if ( c == 2 ) + { + TPtrC8 attrname( aAttributes[0].Attribute().LocalName().DesC() ); + TPtrC8 attrnameval( aAttributes[0].Value().DesC() ); + TPtrC8 attrval( aAttributes[1].Attribute().LocalName().DesC() ); + TPtrC8 attrvalval( aAttributes[1].Value().DesC() ); + RDEBUG8_5( " Name '%S'='%S' Val '%S'='%S' ",&attrname, &attrnameval, + &attrval, &attrvalval ); + if ( attrname == Reader::KIOAttrName ) + { + if ( attrval == Reader::KIOAttrValue ) + { + if ( name == Reader::KIOStdOpt ) + { + if ( attrnameval == KIOKill ) + { + RDEBUG8_2( " Setting iKillApp to %S ", &attrvalval ); + SetPolicyValue( iResult.iKillApp, attrvalval ); + } + else + { + RDEBUG8_3( " WARNING Unsupported name attribute value: '%S' for '%S' ", &attrnameval, &name ); + } + } + else if ( name == Reader::KIOStdSymOpt ) + { + if ( attrnameval == KUIOBreakDependency ) + { + RDEBUG8_2( " Setting iDependecyBreak to %S ", &attrvalval ); + SetPolicyValue( iResult.iBreakDependency, attrvalval ); + } + else + { + RDEBUG8_3( " WARNING Unsupported name attribute value: '%S' for '%S' ", &attrnameval, &name ); + } + } + else + { + RDEBUG("WARNING, unsupported name attribute value"); + } + } + else + { + RDEBUG8_3( " ERROR invalid second attribute!: '%S', expteced: '%S' ", &attrval, &Reader::KIOAttrValue() ); + } + } + else + { + RDEBUG8_3( " ERROR invalid first attribute!: '%S', expteced: '%S' ", &attrname, &Reader::KIOAttrName() ); + } + } + else + { + RDEBUG8_3( " ERROR unsupported count of attributes!!: '%d' for '%S' ", c, &name); + } + } + else + { + RDEBUG( " ERROR custom options not implemented!!!!" ); + + } + } + + +/////////////////////////////////////////////////// +// +// InstallOptionsParser +// +/////////////////////////////////////////////////// + +EXPORT_C void InstallOptionsParser::ParseOptionsL( const TDesC8 &aBuffer, SwiUI::TInstallOptions &aResult) + { + NApplicationManagement::TAMInstallOptions opts; + opts.iOptions.iUsePhoneLang = EFalse; + CAMInstOptsParser *parser = CAMInstOptsParser::NewLC( aBuffer, opts ); + parser->ParseL(); + aResult = opts.iOptions; + CleanupStack::PopAndDestroy( parser ); + } + +EXPORT_C void InstallOptionsParser::ParseOptionsL( const TDesC8 &aBuffer, NApplicationManagement::TAMInstallOptions &aResult) + { + aResult.iOptions.iUsePhoneLang = EFalse; + CAMInstOptsParser *parser = CAMInstOptsParser::NewLC( aBuffer, aResult ); + parser->ParseL(); + CleanupStack::PopAndDestroy( parser ); + } + +EXPORT_C void InstallOptionsParser::ParseOptionsL( const TDesC8 &aBuffer, SwiUI::TUninstallOptions &aResult) + { + CAMUninstOptsParser *parser = CAMUninstOptsParser::NewLC( aBuffer, aResult ); + parser->ParseL(); + CleanupStack::PopAndDestroy( parser ); + } + +EXPORT_C void InstallOptionsParser::SerializeOptionsL( const SwiUI::TUninstallOptions &aOptions, CBufBase &aResult ) + { + using namespace AMXml; + using namespace AMXml::Writer; + using namespace SwiUI; + + aResult.InsertL(aResult.Size(), Writer::KUIOStartElement ); + + HBufC8 *tmp = HBufC8::NewLC( 128 ); + TPtr8 ptmp( tmp->Des() ); + + if ( aOptions.iKillApp != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdOptFormat, &KIOKill, ( aOptions.iKillApp == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( aOptions.iBreakDependency != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KUIOBreakDependency, ( aOptions.iKillApp == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + aResult.InsertL(aResult.Size(), Writer::KUIOStartElementEnd ); + + CleanupStack::PopAndDestroy( tmp ); + } + +EXPORT_C void InstallOptionsParser::SerializeOptionsL( const SwiUI::TInstallOptions &aOptions, CBufBase &aResult ) + { + NApplicationManagement::TAMInstallOptions options; + options.iOptions = aOptions; + SerializeOptionsL( options, aResult ); + } + +EXPORT_C void InstallOptionsParser::SerializeOptionsL( const NApplicationManagement::TAMInstallOptions &aOptions, CBufBase &aResult ) + { + + using namespace AMXml; + using namespace AMXml::Writer; + using namespace SwiUI; + + const SwiUI::TInstallOptions &options = aOptions.iOptions; + + aResult.InsertL(aResult.Size(), Writer::KIOStartElement ); + + HBufC8 *tmp = HBufC8::NewLC( 128 ); + TPtr8 ptmp( tmp->Des() ); + TBuf8<1> b ; + b.Append( options.iDrive ); + ptmp.Format( KIOStdOptFormat, &KIODrive, &b ); + aResult.InsertL( aResult.Size(), ptmp ); + + if( options.iUsePhoneLang ) + { + ptmp.Format( KIOStdOptFormat, &KIOLanguage, &KIODefaultLanguage ) ; + } + else + { + if( options.iLang != ELangNone ) + { + TBool found( EFalse ); + for( TInt i( 0 ); !found && i < KNumLangOptions; i++ ) + { + if ( KLangOptions[i].iLang == options.iLang ) + { + #ifdef _DEBUG + TPtrC8 code( KLangOptions[i].iCode ); + RDEBUG8_2( " InstallOptionsParser::SerializeOptionsL : Found language %S", &code ); + #endif + TPtrC8 p( KLangOptions[i].iCode ); + ptmp.Format( KIOStdOptFormat, &KIOLanguage, &p ) ; + + found = ETrue; + } + } + if ( !found ) + { + ptmp.Format( KNullDesC8() ); + } + } + else + { + ptmp.Format( KNullDesC8() ); + } + } + aResult.InsertL( aResult.Size(), ptmp ); + + if ( options.iUpgrade != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdOptFormat, &KIOUpgrade, ( options.iUpgrade == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + + } + if ( options.iKillApp != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdOptFormat, &KIOKill, ( options.iKillApp == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iPackageInfo != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KIOPkginfo, ( options.iPackageInfo == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iCapabilities != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KIOCapabilities, ( options.iCapabilities == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iUntrusted != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KIOUntrusted, ( options.iUntrusted == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iOCSP != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KIOOCSP, ( options.iOCSP == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iIgnoreOCSPWarnings != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KIOOCSPWarning, ( options.iIgnoreOCSPWarnings == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iOptionalItems != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KIOOptionalItems, ( options.iOptionalItems == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iOverwrite != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KIOOverwrite, ( options.iOverwrite == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iUpgradeData != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdSymOptFormat, &KIOUpgradeData, ( options.iUpgradeData == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iDownload != EPolicyUserConfirm ) + { + ptmp.Format( KIOStdOptFormat, &KIODownload, ( options.iDownload == EPolicyAllowed ? &KIOValueTrue : &KIOValueFalse ) ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iPassword != KNullDesC() ) + { + TBuf8 password; + password.Copy( options.iPassword ); + ptmp.Format( KIOStdOptFormat, &KIOHttpPassword, &password ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( options.iLogin != KNullDesC() ) + { + TBuf8 login; + login.Copy( options.iLogin ); + ptmp.Format( KIOStdOptFormat, &KIOHttpUsername, &login ); + aResult.InsertL( aResult.Size(), ptmp ); + } + if ( aOptions.iConRef != KNullDesC8() ) + { + ptmp.Format( KIOStdOptFormat, &KIOIAP, &aOptions.iConRef); + aResult.InsertL( aResult.Size(), ptmp ); + } + aResult.InsertL( aResult.Size(), KIOStartElementEnd ); + + CleanupStack::PopAndDestroy( tmp ); + } + +// End of File