/*
* 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 <e32debug.h>
#include <s32mem.h>
#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, "<InstOpts>") ;
_LIT8( KIOStdOptFormat, "<StdOpt name=\"%S\" value=\"%S\"/>" );
_LIT8( KIOStdSymOptFormat, "<StdSymOpt name=\"%S\" value=\"%S\"/>" );
// notimp _LIT8( KIOCustSymOptsStartFormat, "<CustSymOpts cnt=\"%d\">" );
// notimp _LIT8( KIOCustSymOptsEnd, "</CustSymOpts>" );
// notimp _LIT8( KIOOptFormat, "<Opt index=\"%d\" value=\"%S\"/>" );
_LIT8( KIOStartElementEnd, "</InstOpts>") ;
_LIT8( KUIOStartElement, "<UninstOpts>" );
_LIT8( KUIOStartElementEnd, "</UninstOpts>" );
}
}
///////////////////////////////////////////////////
//
// 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<KSWInstMaxPasswordLength> password;
password.Copy( options.iPassword );
ptmp.Format( KIOStdOptFormat, &KIOHttpPassword, &password );
aResult.InsertL( aResult.Size(), ptmp );
}
if ( options.iLogin != KNullDesC() )
{
TBuf8<KSWInstMaxUserNameLength> 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