diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/protocol/src/ncdrequestbase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/protocol/src/ncdrequestbase.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,395 @@ +/* +* Copyright (c) 2006 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: CNcdRequestBase declaration +* +*/ + + +#include "ncdrequestbase.h" +#include "ncdrequestconfigurationdata.h" +#include "ncdprotocolwords.h" +#include "ncdprotocolutils.h" +#include "ncd_cp_detail.h" +#include "ncd_cp_cookie.h" +#include "ncd_cp_queryresponse.h" +#include "ncdqueryitem.h" +#include "catalogsdebug.h" + + +CNcdRequestBase* CNcdRequestBase::NewL() + { + CNcdRequestBase* self = + CNcdRequestBase::NewLC(); + CleanupStack::Pop(); + return self; + } + +CNcdRequestBase* CNcdRequestBase::NewLC() + { + CNcdRequestBase* self = new (ELeave) CNcdRequestBase(); + CleanupStack::PushL(self); + self->ConstructL( KTagPreminetRequest ); + return self; + } + +void CNcdRequestBase::ConstructL( const TDesC8& aRootName ) + { + DLTRACEIN(( "aRootName=%S", &aRootName )); + iRootName = aRootName.AllocL(); + + iPrefix = TXmlEngString(); + iId = TXmlEngString(); + iNamespace = TXmlEngString(); + iVersion = TXmlEngString(); + iSession = TXmlEngString(); + +#ifdef RD_XML_ENGINE_API_CHANGE + iDomImplementation.OpenL(); +#endif + InitializeDocumentL(); + DLTRACEOUT(("")); + } + +CNcdRequestBase::CNcdRequestBase() + { + } + +CNcdRequestBase::~CNcdRequestBase() + { + DLTRACEIN(("")); + delete iConfiguration; + + iCookies.ResetAndDestroy(); + iQueryResponses.ResetAndDestroy(); + + iDocument.Close(); // NOTE: leaks memory (S60 3.2 wk38 emulator) +#ifdef RD_XML_ENGINE_API_CHANGE + iDomImplementation.Close(); +#endif + + iId.Free(); + iVersion.Free(); + iSession.Free(); + iNamespace.Free(); + iPrefix.Free(); + + delete iRootName; + DLTRACEOUT(("")); + } + +HBufC8* CNcdRequestBase::ExternalizeL() + { + DLTRACEIN(("")); + + const TXmlEngSerializationOptions KSerializationOptions = + TXmlEngSerializationOptions( 0x09, KSerializationOptionUtf8 ); + +#ifndef RD_XML_ENGINE_API_CHANGE + TXmlEngString str; + iDocument.SaveL(str, iRoot, KSerializationOptions); + + str.PushL(); + + HBufC8* buf = HBufC8::NewL( str.Size() ); + *buf = str.PtrC8(); + + // Free the original C-string + CleanupStack::PopAndDestroy(); +#else + + RBuf8 rbuf; + iDocument.SaveL( rbuf, iRoot, KSerializationOptions ); + + CleanupClosePushL( rbuf ); + HBufC8* buf = rbuf.AllocL(); + CleanupStack::PopAndDestroy(); // rbuf + +#endif + + DLTRACEOUT(("")); + return buf; + } + +HBufC8* CNcdRequestBase::CreateRequestL() + { + DLTRACEIN(("")); + // check required attributes + if (iNamespace.IsNull() || iVersion.IsNull()) + { + DLERROR(("not creating request")); + DASSERT( 0 ); + // do not create request if required attributes are not set + DLTRACEOUT(( "NULL" )); + return NULL; + } + + // namespace, required + NcdProtocolUtils::NewAttributeL( iRoot, KAttrNamespace, iNamespace); + + // id, optional + if (iId.NotNull()) + { + NcdProtocolUtils::NewAttributeL( iRoot, KAttrId, iId ); + } + + // version, required + NcdProtocolUtils::NewAttributeL( iRoot, KAttrVersion, iVersion); + + // session, optional + if (iSession.NotNull()) + { + NcdProtocolUtils::NewAttributeL( iRoot, KAttrSession, iSession); + } + + // configuration, optional + if (iConfiguration) + { + TXmlEngElement configuration = + iConfiguration->GetConfigurationElementL(iDocument); + if (configuration.NotNull()) + iRoot.AppendChildL(configuration); + + TXmlEngElement cookies = + iConfiguration->GetCookiesElementL(iDocument); + if (cookies.NotNull()) + iRoot.AppendChildL(cookies); + + TXmlEngElement queryResponse = + iConfiguration->GetQueryResponseElementL(iDocument); + if (queryResponse.NotNull()) + iRoot.AppendChildL(queryResponse); + } + + // cookies, optional + TXmlEngElement cookies = GetCookiesElementL(KCdpNamespacePrefix); + if ( cookies.NotNull() ) + { + iRoot.AppendChildL(cookies); + } + + TXmlEngElement queryResponses = GetQueryResponsesElementL(KCdpNamespacePrefix); + if ( queryResponses.NotNull() ) + { + iRoot.AppendChildL(queryResponses); + } + + // add element generated in the inheriting class, one of the following: + // browse / search / manageSubscriptions / purchase / + // installationReport / diffQuery + iRoot.AppendChildL(iRequestElement); + + + HBufC8* result = ExternalizeL(); + + DLTRACEOUT(("")); + return result; + } + +void CNcdRequestBase::InitializeDocumentL() + { + DLTRACEIN(("")); + if (iDocument.NotNull()) + { + iDocument.Close(); // ! this leaks! + } + +#ifndef RD_XML_ENGINE_API_CHANGE + iDocument = RXmlEngDocument::NewL(); +#else + iDocument.OpenL( iDomImplementation ); +#endif + iRoot = iDocument.CreateDocumentElementL(*iRootName); + +#ifndef RD_XML_ENGINE_API_CHANGE + TXmlEngString defNs; + NcdProtocolUtils::DesToStringL(defNs, KDefaultNamespaceUri); + iRoot.SetDefaultNamespaceL( defNs ); + defNs.Free(); + + TXmlEngString cdpNs; + NcdProtocolUtils::DesToStringL(cdpNs, KCdpNamespaceUri); + TXmlEngString cdpNsPrefix; + NcdProtocolUtils::DesToStringL(cdpNsPrefix, KCdpNamespacePrefix); + iCdpNamespace = iRoot.AddNamespaceDeclarationL( cdpNs, cdpNsPrefix ); + cdpNs.Free(); + cdpNsPrefix.Free(); + + TXmlEngString xsNs; + NcdProtocolUtils::DesToStringL(xsNs, KXsNamespaceUri); + TXmlEngString xsNsPrefix; + NcdProtocolUtils::DesToStringL(xsNsPrefix, KXsNamespacePrefix); + iXsNamespace = iRoot.AddNamespaceDeclarationL(xsNs, xsNsPrefix); + xsNs.Free(); + xsNsPrefix.Free(); + + TXmlEngString xsiNs; + NcdProtocolUtils::DesToStringL(xsiNs, KXsiNamespaceUri); + TXmlEngString xsiNsPrefix; + NcdProtocolUtils::DesToStringL(xsiNsPrefix, KXsiNamespacePrefix); + iXsiNamespace = iRoot.AddNamespaceDeclarationL(xsiNs, xsiNsPrefix); + xsiNs.Free(); + xsiNsPrefix.Free(); + +#else + iRoot.SetDefaultNamespaceL( KDefaultNamespaceUri ); + iCdpNamespace = iRoot.AddNamespaceDeclarationL( KCdpNamespaceUri, KCdpNamespacePrefix ); + iXsNamespace = iRoot.AddNamespaceDeclarationL( KXsNamespaceUri, KXsNamespacePrefix ); + iXsiNamespace = iRoot.AddNamespaceDeclarationL( KXsiNamespaceUri, KXsiNamespacePrefix ); +#endif + + DLTRACEOUT(("")); + } + +CNcdRequestConfigurationData* CNcdRequestBase::Configuration() + { + return iConfiguration; + } + +void CNcdRequestBase::SetConfigurationL( + CNcdRequestConfigurationData* aConfiguration) + { + DLTRACEIN(("")); + delete iConfiguration; + iConfiguration = aConfiguration; + } + +void CNcdRequestBase::SetRequestIdL(TInt aId) + { + TBuf<32> buf; + buf.AppendNum(aId); + TXmlEngString id; + id.SetL(buf); + iId = id; + } + +void CNcdRequestBase::SetProtocolVersionL(const TDesC8& aVersion) + { + iVersion.SetL(aVersion); + } + +void CNcdRequestBase::SetSessionL(const TDesC& aSession) + { + iSession.SetL(aSession); + } + +void CNcdRequestBase::SetNamespaceL( const TDesC& aNamespace) + { + iNamespace.SetL(aNamespace); + } + +HBufC* CNcdRequestBase::IdLC() const + { + return iId.AllocLC(); + } + +HBufC* CNcdRequestBase::SessionLC() const + { + return iSession.AllocLC();; + } + +HBufC* CNcdRequestBase::NamespaceLC() const + { + return iNamespace.AllocLC(); + } + +void CNcdRequestBase::AddQueryResponseL(MNcdConfigurationProtocolQueryResponse* aResponse) + { + iQueryResponses.AppendL(aResponse); + } + +void CNcdRequestBase::AddCookieL(MNcdConfigurationProtocolCookie* aCookie) + { + iCookies.AppendL(aCookie); + } + +TXmlEngElement CNcdRequestBase::GetCookiesElementL( const TDesC8& aPrefix ) + { + TXmlEngElement cookies; + + if ( iCookies.Count() > 0 ) + { + cookies = NcdProtocolUtils::NewElementL( iDocument, iRoot, KTagCookies ); + for ( TInt i = 0; i < iCookies.Count(); ++i ) + { + MNcdConfigurationProtocolCookie* cook = iCookies[i]; + TXmlEngElement cookie = + NcdProtocolUtils::NewElementL( iDocument, cookies, KTagCookie ); + NcdProtocolUtils::NewAttributeL( cookie, KAttrKey, cook->Key() ); + for ( TInt j = 0; j < cook->ValueCount(); ++j ) + { + TXmlEngElement value = + NcdProtocolUtils::NewElementL( iDocument, cookie, KTagValue, aPrefix ); +#ifndef RD_XML_ENGINE_API_CHANGE + value.SetTextL( cook->Value(j) ); +#else + HBufC8* tempBuf = NcdProtocolUtils::ConvertUnicodeToUtf8L( cook->Value(j) ); + CleanupStack::PushL( tempBuf ); + value.SetTextL( *tempBuf ); + CleanupStack::PopAndDestroy( tempBuf ); +#endif + } + } + } + return cookies; + } + +TXmlEngElement CNcdRequestBase::GetQueryResponsesElementL( const TDesC8& aPrefix ) + { + TXmlEngElement queryResponse; + // queryResponses, optional + if ( iQueryResponses.Count() > 0 ) + { + for (TInt i = 0; i < iQueryResponses.Count(); ++i) + { + MNcdConfigurationProtocolQueryResponse* resp = iQueryResponses[i]; + queryResponse = NcdProtocolUtils::NewElementL(iDocument, iRoot, KTagQueryResponse); + if ( resp->Id() != KNullDesC ) + NcdProtocolUtils::NewAttributeL(queryResponse, KAttrId, resp->Id()); + if ( resp->Semantics() != MNcdQueryItem::ESemanticsNone ) + NcdProtocolUtils::NewAttributeL(queryResponse, KAttrSemantics, resp->Semantics()); + if ( resp->Cancel() ) + NcdProtocolUtils::NewBoolAttributeL(queryResponse, KAttrCancel, resp->Cancel()); + + for (TInt j = 0; j < resp->ResponseCount(); ++j) + { + const MNcdConfigurationProtocolQueryResponseValue& val = resp->ResponseL(j); + TXmlEngElement response = NcdProtocolUtils::NewElementL( + iDocument, queryResponse, KTagResponse, aPrefix); + NcdProtocolUtils::NewAttributeL(response, KAttrId, val.Id()); + NcdProtocolUtils::NewAttributeL(response, KAttrSemantics, val.Semantics()); + for (TInt k = 0; k < val.ValueCount(); ++k) + { + TXmlEngElement value = NcdProtocolUtils::NewElementL( + iDocument, response, KTagValue, aPrefix); +#ifndef RD_XML_ENGINE_API_CHANGE + value.SetTextL( val.ValueL(k) ); +#else + HBufC8* tempBuf = NcdProtocolUtils::ConvertUnicodeToUtf8L( val.ValueL(k) ); + CleanupStack::PushL( tempBuf ); + value.SetTextL( *tempBuf ); + CleanupStack::PopAndDestroy( tempBuf ); +#endif + } + } + } + } + return queryResponse; + } + + +TXmlEngElement CNcdRequestBase::GetDetailsElementL( const TDesC8& /*aPrefix*/ ) + { + DLTRACEIN(("")); + return TXmlEngElement(); + }