diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/server/src/ncdpurchaseoptionimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/server/src/ncdpurchaseoptionimpl.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,857 @@ +/* +* 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: Implements CNcdPurchaseOptionImpl class +* +*/ + + +#include "ncdpurchaseoptionimpl.h" +#include "ncdserversubscription.h" +#include "ncdserverpartofsubscription.h" +#include "ncdserverupgrade.h" +#include "ncdnodemetadataimpl.h" +#include "catalogssession.h" +#include "catalogsbasemessage.h" +#include "ncdnodefunctionids.h" +#include "catalogsconstants.h" +#include "ncd_pp_download.h" +#include "ncd_pp_purchaseoption.h" +#include "ncd_pp_subscriptiondetails.h" +#include "ncd_pp_descriptor.h" +#include "ncd_pp_rights.h" +#include "ncd_cp_query.h" +#include "ncdutils.h" +#include "catalogsutils.h" +#include "catalogsdebug.h" + + +CNcdPurchaseOptionImpl::CNcdPurchaseOptionImpl( + NcdNodeClassIds::TNcdNodeClassId aClassId, + const CNcdNodeMetaData& aParentMetaData ) + : CCatalogsCommunicable(), + iClassId( aClassId ), + iParentMetaData( aParentMetaData ), + iPrice( -1 ), + iIsFree( EFalse ), + iRequirePurchaseProcess( ETrue ) + { + } + +void CNcdPurchaseOptionImpl::ConstructL() + { + } + +CNcdPurchaseOptionImpl* CNcdPurchaseOptionImpl::NewL( + const CNcdNodeMetaData& aParentMetaData ) + { + CNcdPurchaseOptionImpl* self = + CNcdPurchaseOptionImpl::NewLC( aParentMetaData ); + CleanupStack::Pop( self ); + return self; + } + +CNcdPurchaseOptionImpl* CNcdPurchaseOptionImpl::NewLC( + const CNcdNodeMetaData& aParentMetaData ) + { + CNcdPurchaseOptionImpl* self = + new( ELeave ) CNcdPurchaseOptionImpl( + NcdNodeClassIds::ENcdItemNodeMetaDataClassId, + aParentMetaData ); + CleanupClosePushL( *self ); + self->ConstructL(); + return self; + } + + +CNcdPurchaseOptionImpl::~CNcdPurchaseOptionImpl() + { + DLTRACEIN(("")); + + ResetMemberVariables(); + + DLTRACEOUT(("")); + } + + +NcdNodeClassIds::TNcdNodeClassId CNcdPurchaseOptionImpl::ClassId() const + { + return iClassId; + } + + +// Internalization from the protocol + +void CNcdPurchaseOptionImpl::InternalizeL( + const MNcdPreminetProtocolPurchaseOption& aOption ) + { + DLTRACEIN(("")); + + // Just to be sure, delete old values of member-variables. + ResetMemberVariables(); + + DLTRACE(( _L("Internalizing purchaseoption from protocol.") )); + + iName = aOption.Name().AllocL(); + + DLTRACE(( _L("Purchaseoption name: %S."), iName )); + + iPriceText = aOption.PriceText().AllocL(); + + iPrice = aOption.Price(); + iPriceCurrency = aOption.PriceCurrency().AllocL(); + + + iIsFree = aOption.IsFree(); + iPurchaseOptionId = aOption.Id().AllocL(); + iRequirePurchaseProcess = aOption.RequirePurchaseProcess(); + + + // Let's create subscription related aggregate classes + InternalizeSubscriptionsInfoL( aOption ); + + + // Let's internalize download details + InternalizeDownloadDetailsL( aOption ); + + DLTRACEOUT(("")); + } + + + + +const CNcdNodeIdentifier& + CNcdPurchaseOptionImpl::ParentMetaIdentifier() const + { + return iParentMetaData.Identifier(); + } + +const CNcdServerSubscribableContent* + CNcdPurchaseOptionImpl::ParentSubscribableContent() const + { + return iParentMetaData.SubscribableContent(); + } + +const CNcdNodeIcon& CNcdPurchaseOptionImpl::ParentIconL() const + { + return iParentMetaData.IconL(); + } + + +const TDesC& CNcdPurchaseOptionImpl::PurchaseOptionName() const + { + // Not an optional element in protocol, no checkings + // done against NULL pointer + return *iName; + } + +void CNcdPurchaseOptionImpl::SetIdL( const TDesC& aId ) + { + HBufC* newId = aId.AllocL(); + delete iPurchaseOptionId; + iPurchaseOptionId = newId; + } + +const TDesC& CNcdPurchaseOptionImpl::Id() const + { + // Not an optional element in protocol, no checkings + // done against NULL pointer + return *iPurchaseOptionId; + } +MNcdPurchaseOption::TType CNcdPurchaseOptionImpl::PurchaseOptionType() const + { + return iType; + } + +TBool CNcdPurchaseOptionImpl::IsFree() const + { + return iIsFree; + } + +TBool CNcdPurchaseOptionImpl::RequirePurchaseProcess() const + { + return iRequirePurchaseProcess; + } + +void CNcdPurchaseOptionImpl::SetPriceTextL( const TDesC& aPriceText ) + { + AssignDesL( iPriceText, aPriceText); + } + +const TDesC& CNcdPurchaseOptionImpl::PriceText() const + { + return *iPriceText; + } + +TInt CNcdPurchaseOptionImpl::DownloadInfoCount() const + { + return iDownloadInfo.Count(); + } + +const CNcdPurchaseDownloadInfo& CNcdPurchaseOptionImpl::DownloadInfo( + TInt aInfoIndex ) const + { + DASSERT( aInfoIndex >= 0 && aInfoIndex < iDownloadInfo.Count() ); + return *iDownloadInfo[aInfoIndex]; + } + +const CNcdServerSubscription* + CNcdPurchaseOptionImpl::SubscriptionInfo() const + { + return iSubscription; + } + +const CNcdServerPartOfSubscription* + CNcdPurchaseOptionImpl::PartOfSubscriptionInfo() const + { + return iPartOfSubscription; + } + +const CNcdServerUpgrade* CNcdPurchaseOptionImpl::UpgradeInfo() const + { + return iUpgrade; + } + +void CNcdPurchaseOptionImpl::SetRecentlyUpdated( TBool aNewState ) + { + DLTRACEIN(("")); + iRecentlyUpdated = aNewState; + DLTRACEOUT(("")); + } + +TBool CNcdPurchaseOptionImpl::RecentlyUpdated() const + { + DLTRACEIN(("")); + DLTRACEOUT(("")); + return iRecentlyUpdated; + } + + +// Internalization from and externalization to the database + +void CNcdPurchaseOptionImpl::ExternalizeL( RWriteStream& aStream ) + { + DLTRACEIN(("")); + + // Set all the membervariable values to the stream. So, + // that the stream may be used later to create a new + // object. + + ExternalizeDataForRequestL( aStream ); + + + // download details are not internalized to proxy-side + // so externalization of downloadinfo to database is + // not done in ExternalizeDataForRequestL. + // It has to be done here. + TInt detailsCount( iDownloadInfo.Count() ); + + // First we write the amount of download details + aStream.WriteInt32L( detailsCount ); + + // Then each details object + TInt detailsIndexer( 0 ); + while ( detailsIndexer < detailsCount ) + { + iDownloadInfo[detailsIndexer]->ExternalizeL( aStream ); + ++detailsIndexer; + } + + + DLTRACEOUT(("")); + } + +void CNcdPurchaseOptionImpl::InternalizeL( RReadStream& aStream ) + { + DLTRACEIN(("")); + + // If there happened to be something stored already + // in this object, destroy it + ResetMemberVariables(); + + aStream.ReadInt32L(); // Class id + + InternalizeDesL( iName, aStream ); + DLINFO(( _L("Internalized name: %S"), iName )); + + InternalizeDesL( iPriceText, aStream ); + + iPrice = aStream.ReadReal32L(); + InternalizeDesL( iPriceCurrency, aStream ); + + + iIsFree = aStream.ReadInt32L(); + + InternalizeDesL( iPurchaseOptionId, aStream ); + + //InternalizeDesL( iPurchase, aStream ); + iType = static_cast(aStream.ReadInt32L()); + DLINFO(( "Internalized purchase option type: %d", iType )); + + iRequirePurchaseProcess = aStream.ReadInt32L(); + + + // Let's internalize subscription related aggregate classes + + // Internalization of these could be moved into + // the aggregate classes + + TBool subscriptionExists( aStream.ReadInt32L() ); + if ( subscriptionExists ) + { + iSubscription = CNcdServerSubscription::NewL(); + + iSubscription->SetValidityDelta( aStream.ReadInt32L() ); + iSubscription->SetValidityAutoUpdate( aStream.ReadInt32L() ); + + TReal32 tmpAmountOfCredits( aStream.ReadReal32L() ); + iSubscription->SetAmountOfCredits( tmpAmountOfCredits ); + + HBufC* tmpAmountOfCreditsCurrency( NULL ); + InternalizeDesL( tmpAmountOfCreditsCurrency, aStream ); + iSubscription->SetAmountOfCreditsCurrency( + tmpAmountOfCreditsCurrency ); + + iSubscription->SetNumberOfDownloads( aStream.ReadInt32L() ); + } + + TBool partOfSubscriptionExists( aStream.ReadInt32L() ); + if ( partOfSubscriptionExists ) + { + iPartOfSubscription = CNcdServerPartOfSubscription::NewL(); + + HBufC* tmpParentEntityId( NULL ); + InternalizeDesL( tmpParentEntityId, aStream ); + iPartOfSubscription->SetParentEntityId( tmpParentEntityId ); + + HBufC* tmpParentPurchaseOptionId( NULL ); + InternalizeDesL( tmpParentPurchaseOptionId, aStream ); + iPartOfSubscription->SetParentPurchaseOptionId( + tmpParentPurchaseOptionId ); + + iPartOfSubscription->SetCreditPrice( aStream.ReadReal32L() ); + } + + TBool upgradeExists( aStream.ReadInt32L() ); + if ( upgradeExists ) + { + iUpgrade = CNcdServerUpgrade::NewL(); + + HBufC* tmpDependencyId( NULL ); + InternalizeDesL( tmpDependencyId, aStream ); + iUpgrade->SetDependencyId( tmpDependencyId ); + + iUpgrade->SetValidityDelta( aStream.ReadInt32L() ); + + TReal32 tmpAmountOfCredits( aStream.ReadReal32L() ); + iUpgrade->SetAmountOfCredits( tmpAmountOfCredits ); + + iUpgrade->SetNumberOfDownloads( aStream.ReadInt32L() ); + } + + + + // Next let's internalize download details + + // First read amount + TInt detailsCount( aStream.ReadInt32L() ); + + // Then each details object + TInt detailsIndexer( 0 ); + while ( detailsIndexer < detailsCount ) + { + CNcdPurchaseDownloadInfo* tempInfo = + CNcdPurchaseDownloadInfo::NewLC(); + + tempInfo->InternalizeL( aStream ); + iDownloadInfo.AppendL( tempInfo ); + CleanupStack::Pop( tempInfo ); + + ++detailsIndexer; + } + + + + DLTRACEOUT(("")); + } + + +void CNcdPurchaseOptionImpl::ReceiveMessage( MCatalogsBaseMessage* aMessage, + TInt aFunctionNumber ) + { + DLTRACEIN(("")); + + DASSERT( aMessage ); + + // Now, we can be sure that rest of the time iMessage exists. + // This member variable is set for the CounterPartLost function. + iMessage = aMessage; + + TInt trapError( KErrNone ); + + // Check which function is called by the proxy side object. + // Function number are located in ncdnodefunctinoids.h file. + switch( aFunctionNumber ) + { + case NcdNodeFunctionIds::ENcdInternalize: + // Internalize the proxy side according to the data + // of this object. + TRAP( trapError, InternalizeRequestL( *aMessage ) ); + break; + + case NcdNodeFunctionIds::ENcdRelease: + // The proxy does not want to use this object anymore. + // So, release the handle from the session. + ReleaseRequest( *aMessage ); + break; + + default: + break; + } + + if ( trapError != KErrNone ) + { + // Because something went wrong, the complete has not been + // yet called for the message. + // So, inform the client about the error if the + // message is still available. + aMessage->CompleteAndRelease( trapError ); + } + + // Because the message should not be used after this, set it NULL. + // So, CounterPartLost function will know that no messages are + // waiting the response at the moment. + iMessage = NULL; + + DLTRACEOUT(("")); + } + +void CNcdPurchaseOptionImpl::CounterPartLost( const MCatalogsSession& aSession ) + { + // This function may be called whenever -- when the message is waiting + // response or when the message does not exist. + // iMessage may be NULL here, because in the end of the + // ReceiveMessage it is set to NULL. The life time of the message + // ends shortly after CompleteAndRelease is called. + if ( iMessage != NULL ) + { + iMessage->CounterPartLost( aSession ); + } + } + + +void CNcdPurchaseOptionImpl::InternalizeRequestL( MCatalogsBaseMessage& aMessage ) const + { + DLTRACEIN(("")); + + CBufBase* buf = CBufFlat::NewL( KBufExpandSize ); + CleanupStack::PushL( buf ); + + RBufWriteStream stream( *buf ); + CleanupClosePushL( stream ); + + + // Include all the necessary node data to the stream + ExternalizeDataForRequestL( stream ); + + + // Commits data to the stream when closing. + CleanupStack::PopAndDestroy( &stream ); + + + // If this leaves, ReceiveMessge will complete the message. + // NOTE: that here we expect that the buffer contains at least + // some data. So, make sure taht ExternalizeDataForRequestL inserts + // something to the buffer. + aMessage.CompleteAndReleaseL( buf->Ptr( 0 ), KErrNone ); + + + DLTRACE(("Deleting the buf")); + CleanupStack::PopAndDestroy( buf ); + + DLTRACEOUT(("")); + } + + +void CNcdPurchaseOptionImpl::ExternalizeDataForRequestL( RWriteStream& aStream ) const + { + DLTRACEIN(("")); + + // First insert data that the creator of this class object will use to + // create this class object. Class id informs what class object + // will be created. + aStream.WriteInt32L( ClassId() ); + + DLINFO(( _L("Externalizing name: %S"), iName )); + + ExternalizeDesL( *iName, aStream ); + ExternalizeDesL( *iPriceText, aStream ); + + aStream.WriteReal32L( iPrice ); + ExternalizeDesL( *iPriceCurrency, aStream ); + + aStream.WriteInt32L( iIsFree ); + + ExternalizeDesL( *iPurchaseOptionId, aStream ); + + //ExternalizeDesL( *iPurchase, aStream ); + aStream.WriteInt32L( iType ); + + DLINFO(( "Externalizing purchase option type: %d", iType )); + + aStream.WriteInt32L( iRequirePurchaseProcess ); + + DLINFO(( "Externalizing require purchase process: %d", iRequirePurchaseProcess )); + + + // Let's externalize subscription related aggregate classes + + // Externalization of these could be moved into + // the aggregate classes + + if ( iSubscription != NULL ) + { + // indicate that subscription exists + aStream.WriteInt32L( ETrue ); + + aStream.WriteInt32L( iSubscription->ValidityDelta() ); + DLINFO(( "Externalized validitydelta: %d", + iSubscription->ValidityDelta() )); + + aStream.WriteInt32L( iSubscription->ValidityAutoUpdate() ); + DLINFO(( "Externalized validity auto update: %d", + iSubscription->ValidityAutoUpdate() )); + + aStream.WriteReal32L( iSubscription->AmountOfCredits() ); + DLINFO(( "Externalized amount of credits: %f.", + iSubscription->AmountOfCredits() )); + + ExternalizeDesL( + iSubscription->AmountOfCreditsCurrency(), + aStream ); + DLINFO(( _L("Externalized credits currency: %S"), + &iSubscription->AmountOfCreditsCurrency() )); + + aStream.WriteInt32L( iSubscription->NumberOfDownloads() ); + DLINFO(( _L("Externalized number of downloads: %d"), + iSubscription->NumberOfDownloads() )); + + } + else + { + // Does not exist + aStream.WriteInt32L( EFalse ); + DLINFO(( _L("Externalizing po impl: Subscription component did not exist.") )); + } + + + if ( iPartOfSubscription != NULL ) + { + // indicate that part of subscription exists + aStream.WriteInt32L( ETrue ); + + DLINFO(( _L("Parent entity id: %S"), + &iPartOfSubscription->ParentEntityId() )); + DLINFO(( _L("Parent entity po id: %S"), + &iPartOfSubscription->ParentPurchaseOptionId() )); + + ExternalizeDesL( + iPartOfSubscription->ParentEntityId(), + aStream ); + ExternalizeDesL( + iPartOfSubscription->ParentPurchaseOptionId(), + aStream ); + + aStream.WriteReal32L( iPartOfSubscription->CreditPrice() ); + + DLINFO(( _L("Externalized part of subscription info") )); + } + else + { + // Does not exist + aStream.WriteInt32L( EFalse ); + DLINFO(( _L("Externalizing po impl: Part of subscription component did not exist.") )); + } + + if ( iUpgrade != NULL ) + { + // indicate that upgrade exists + aStream.WriteInt32L( ETrue ); + + ExternalizeDesL( iUpgrade->DependencyId(), aStream ); + DLINFO(( _L("Upgrade dependency id: %S"), + &iUpgrade->DependencyId() )); + + aStream.WriteInt32L( iUpgrade->ValidityDelta() ); + aStream.WriteReal32L( iUpgrade->AmountOfCredits() ); + aStream.WriteInt32L( iUpgrade->NumberOfDownloads() ); + } + else + { + // Does not exist + aStream.WriteInt32L( EFalse ); + DLINFO(( _L("Externalizing po impl: Upgrade component did not exist.") )); + } + + DLTRACEOUT(("")); + } + +void CNcdPurchaseOptionImpl::ReleaseRequest( MCatalogsBaseMessage& aMessage ) const + { + DLTRACEIN(("")); + + // Decrease the reference count for this object. + // When the reference count reaches zero, this object will be destroyed + // and removed from the session. + MCatalogsSession& requestSession( aMessage.Session() ); + TInt handle( aMessage.Handle() ); + + // Send complete information back to proxy. + aMessage.CompleteAndRelease( KErrNone ); + + // Remove this object from the session. + requestSession.RemoveObject( handle ); + + DLTRACEOUT(("")); + } + + +void CNcdPurchaseOptionImpl::InternalizeSubscriptionsInfoL( + const MNcdPreminetProtocolPurchaseOption& aOption ) + { + + DLTRACEIN(("")); + + TNcdPurchaseType purchase = aOption.Purchase(); + + // Conversion to type declared in the purchaseoption interface + + switch ( purchase ) + { + case ETypeNotSet: // Flow through, default is EContent + case EContent: + iType = MNcdPurchaseOption::EPurchase; + break; + case ESubscription: + iType = MNcdPurchaseOption::ESubscription; + break; + case EPartOfSubscription: + iType = MNcdPurchaseOption::ESubscriptionPurchase; + break; + case EUpgrade: + iType = MNcdPurchaseOption::ESubscriptionUpgrade; + break; + default: + DASSERT( false ); // unsupported type + break; + } + + DLTRACE(( _L("Purchaseoption impl, purchase option type: %d."), + iType )); + + + // Po cannot be a subscription and an upgrade at the same time + // because they use same variables with different meaning + if( purchase == EUpgrade ) + { + iUpgrade = CNcdServerUpgrade::NewL(); + + // If subscription upgrade the po that is upgraded. + // Possibly also some other meaning? + iUpgrade->SetDependencyId( aOption.DependencyId().AllocL() ); + + // Subscription upgrade stuff... + iUpgrade->SetValidityDelta( aOption.SubscriptionDetails()->ValidityDelta() ); + iUpgrade->SetAmountOfCredits( + aOption.SubscriptionDetails()->AmountOfCredits() ); + iUpgrade->SetNumberOfDownloads( + aOption.SubscriptionDetails()->NumberOfDownloads() ); + + DLINFO(( "Purchaseoption impl, upgrade, amount of credits: %f.", + iUpgrade->AmountOfCredits() )); + DLINFO(( "Purchaseoption impl, upgrade, validitydelta: %d.", + iUpgrade->ValidityDelta() )); + DLINFO(( "Purchaseoption impl, upgrade, downloads: %d.", + iUpgrade->NumberOfDownloads() )); + + } + else if ( purchase == ESubscription ) + { + // check if we have a subscription + + iSubscription = CNcdServerSubscription::NewL(); + + iSubscription->SetValidityDelta( + aOption.SubscriptionDetails()->ValidityDelta() ); + iSubscription->SetValidityAutoUpdate( + aOption.SubscriptionDetails()->ValidityAutoUpdate() ); + iSubscription->SetAmountOfCredits( + aOption.SubscriptionDetails()->AmountOfCredits() ); + iSubscription->SetAmountOfCreditsCurrency( + aOption.SubscriptionDetails()->AmountOfCreditsCurrency().AllocL() ); + iSubscription->SetNumberOfDownloads( + aOption.SubscriptionDetails()->NumberOfDownloads() ); + + DLINFO(( "Purchaseoption impl, subscription, amount of credits in protocol: %f.", + aOption.SubscriptionDetails()->AmountOfCredits() )); + DLINFO(( "Purchaseoption impl, subscription, amount of credits: %f.", + iSubscription->AmountOfCredits() )); + DLINFO(( "Purchaseoption impl, subscription, validitydelta: %d.", + iSubscription->ValidityDelta() )); + DLINFO(( "Purchaseoption impl, subscription, downloads: %d.", + iSubscription->NumberOfDownloads() )); + } + + // Still have to check if we have a part of subscription + + DLTRACE(( _L("Purchaseoption impl, Checking part of subscription info.") )); + + const TDesC& tmpParentSubscriptionEntityId = + aOption.ParentSubscriptionEntityId(); + + DLTRACE(( _L("Purchaseoption impl, parent entity id: \"%S\"."), + &tmpParentSubscriptionEntityId )); + + // According to protocol if we have a part of subscription then + // parent subscription entity id is a mandatory field. + if ( tmpParentSubscriptionEntityId != KNullDesC ) + { + iPartOfSubscription = CNcdServerPartOfSubscription::NewL(); + + iPartOfSubscription->SetParentEntityId( + aOption.ParentSubscriptionEntityId().AllocL() ); + iPartOfSubscription->SetParentPurchaseOptionId( + aOption.ParentSubscriptionPurchaseOptionId().AllocL() ); + iPartOfSubscription->SetCreditPrice( aOption.CreditPrice() ); + + + DLINFO(( "Purchaseoption impl, part of subscription, credit price: %f.", + iPartOfSubscription->CreditPrice() )); + DLINFO(( _L("Purchaseoption impl, part of subscription, parent entity id: %S."), + &iPartOfSubscription->ParentEntityId() )); + DLINFO(( _L("Purchaseoption impl, part of subscription, parent po id: %S."), + &iPartOfSubscription->ParentPurchaseOptionId() )); + } + + DLTRACEOUT(("")); + } + + + +void CNcdPurchaseOptionImpl::InternalizeDownloadDetailsL( + const MNcdPreminetProtocolPurchaseOption& aOption ) + { + DLTRACEIN(("")); + + const TInt KDetailsCount( aOption.DownloadDetailsCount() ); + TInt detailsIndexer( 0 ); + + DLTRACE(( _L("Purchaseoption download details amount: %d."), + KDetailsCount )); + + while ( detailsIndexer < KDetailsCount ) + { + const MNcdPreminetProtocolDownload& tmpDownloadDetails = + aOption.DownloadDetailsL( detailsIndexer ); + + CNcdPurchaseDownloadInfo* tempInfo = + CNcdPurchaseDownloadInfo::NewLC(); + + TNcdDownloadTargetType tmpTarget = tmpDownloadDetails.Target(); + // Conversion from TNcdDownloadTargetType to TContentUsage + MNcdPurchaseDownloadInfo::TContentUsage tmpUsage = + MNcdPurchaseDownloadInfo::EDownloadable; + + switch ( tmpTarget ) + { + case EDownloadTargetDownloadable: + tmpUsage = MNcdPurchaseDownloadInfo::EDownloadable; + break; + case EDownloadTargetConsumable: + tmpUsage = MNcdPurchaseDownloadInfo::EConsumable; + break; + default: + DASSERT( false ); // unsupported type + break; + } + tempInfo->SetContentUsage( tmpUsage ); + + tempInfo->SetContentUriL( tmpDownloadDetails.Uri() ); + tempInfo->SetContentMimeTypeL( tmpDownloadDetails.Mime() ); + tempInfo->SetContentSize( tmpDownloadDetails.Size() ); + tempInfo->SetLaunchable( tmpDownloadDetails.Launchable() ); + + + const MNcdPreminetProtocolDescriptor* descriptor = + tmpDownloadDetails.Descriptor(); + if ( descriptor != NULL ) + { + tempInfo->SetDescriptorTypeL( descriptor->Type() ); + tempInfo->SetDescriptorNameL( descriptor->Name() ); + tempInfo->SetDescriptorUriL( descriptor->Uri() ); + tempInfo->SetDescriptorDataL( descriptor->Data() ); + } + + + const MNcdPreminetProtocolRights* rights = + tmpDownloadDetails.Rights(); + if ( rights != NULL ) + { + tempInfo->SetRightsUriL( rights->Uri() ); + tempInfo->SetRightsTypeL( rights->Type() ); + } + + tempInfo->SetContentValidityDelta( + tmpDownloadDetails.ValidityDelta() ); + + iDownloadInfo.AppendL( tempInfo ); + CleanupStack::Pop( tempInfo ); + + ++detailsIndexer; + } + + DLTRACEOUT(("")); + } + + +void CNcdPurchaseOptionImpl::ResetMemberVariables() + { + // In all cases this state variable is in the beginning false + // This has to be set especially by the user. + iRecentlyUpdated = EFalse; + + delete iName; + iName = NULL; + delete iPriceText; + iPriceText = NULL; + + iPrice = -1; + delete iPriceCurrency; + iPriceCurrency = NULL; + + iIsFree = EFalse; + delete iPurchaseOptionId; + iPurchaseOptionId = NULL; + + iType = MNcdPurchaseOption::EPurchase; + iRequirePurchaseProcess = EFalse; + + iDownloadInfo.ResetAndDestroy(); + + delete iSubscription; + iSubscription = NULL; + delete iPartOfSubscription; + iPartOfSubscription = NULL; + delete iUpgrade; + iUpgrade = NULL; + }