1 /*

     2 * Copyright (c) 2006-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  

    15 *

    16 */

    17 

    18 

    19 #include <s32strm.h>

    20 

    21 #include "ncdpurchasedetails.h"

    22 #include "ncdpurchasedownloadinfo.h"

    23 #include "ncdpurchaseinstallinfo.h"

    24 #include "catalogsutils.h"

    25 #include "catalogsconstants.h"

    26 #include "ncdutils.h"

    27 #include "ncdattributes.h"

    28 

    29 #include "catalogsdebug.h"

    30 

    31 

    32 static inline void AssignHBufC( HBufC*& aDes, HBufC* const aSource )

    33     {

    34     delete aDes;

    35     aDes = aSource;

    36     }

    37 

    38 EXPORT_C CNcdPurchaseDetails* CNcdPurchaseDetails::NewL()

    39     {

    40     CNcdPurchaseDetails* self = NewLC();

    41     CleanupStack::Pop( self );

    42     return self;

    43     }

    44 

    45 EXPORT_C CNcdPurchaseDetails* CNcdPurchaseDetails::NewLC()

    46     {

    47     CNcdPurchaseDetails* self = new ( ELeave ) CNcdPurchaseDetails;

    48     CleanupStack::PushL( self );

    49     self->ConstructL();

    50     return self;    

    51     }

    52 

    53 EXPORT_C CNcdPurchaseDetails* CNcdPurchaseDetails::NewL(

    54     const MNcdPurchaseDetails& aDetails )

    55     {

    56     CNcdPurchaseDetails* self = NewLC( aDetails );

    57     CleanupStack::Pop( self );

    58     return self;

    59     }

    60     

    61 EXPORT_C CNcdPurchaseDetails* CNcdPurchaseDetails::NewLC(

    62     const MNcdPurchaseDetails& aDetails )

    63     {

    64     DLTRACEIN((""));

    65     CNcdPurchaseDetails* self = new ( ELeave ) CNcdPurchaseDetails;

    66     CleanupStack::PushL( self );

    67     self->ConstructL();

    68     

    69     self->SetCatalogSourceNameL( aDetails.CatalogSourceName() );

    70     self->SetClientUid( aDetails.ClientUid() );

    71     self->SetDescriptionL( aDetails.Description() );

    72     self->SetDownloadAccessPointL( aDetails.DownloadAccessPoint() );

    73     self->SetDownloadedFilesL( aDetails.DownloadedFiles() );

    74     self->SetDownloadInfoL( aDetails.DownloadInfoL() );

    75     self->SetEntityIdL( aDetails.EntityId() );

    76     self->SetFinalPriceL( aDetails.FinalPrice() );

    77     self->SetIconL( aDetails.Icon() );

    78     self->SetInstallInfoL( aDetails.InstallInfoL() );

    79     self->SetItemNameL( aDetails.ItemName() );

    80     self->SetItemPurpose( aDetails.ItemPurpose() );

    81     self->SetNamespaceL( aDetails.Namespace() );

    82     self->SetPaymentMethodNameL( aDetails.PaymentMethodName() );

    83     self->SetPurchaseOptionIdL( aDetails.PurchaseOptionId() );

    84     self->SetPurchaseOptionNameL( aDetails.PurchaseOptionName() );

    85     self->SetPurchaseOptionPriceL( aDetails.PurchaseOptionPrice() );

    86     self->SetPurchaseTime( aDetails.PurchaseTime() );

    87     self->SetVersionL( aDetails.Version() );

    88     self->SetServerUriL( aDetails.ServerUri() );

    89     self->SetItemType( aDetails.ItemType() );

    90     self->SetTotalContentSize( aDetails.TotalContentSize() );

    91     self->SetLastOperationTime( aDetails.LastOperationTime() );

    92     self->SetLastOperationErrorCode( aDetails.LastOperationErrorCode() );

    93     self->SetOriginNodeIdL( aDetails.OriginNodeId() );

    94 

    95     // Some ugly stuff for copying the attributes

    96     // This WILL NOT work for other MNcdPurchaseDetails-implementations

    97     // if there's going to be any

    98     const CNcdPurchaseDetails& details = 

    99         static_cast<const CNcdPurchaseDetails&>( aDetails );

   100     

   101     if ( details.iAttributes ) 

   102         {

   103         DeletePtr( self->iAttributes );

   104         self->iAttributes = CNcdAttributes::NewL( *details.iAttributes );

   105         }

   106 

   107     return self;    

   108     }

   109 

   110 CNcdPurchaseDetails::~CNcdPurchaseDetails()

   111     {

   112     delete iNamespace;

   113     delete iEntityId;

   114     delete iItemName;

   115     delete iCatalogSourceName;

   116     ResetAndDestroyWithCast< CNcdPurchaseDownloadInfo >( iDownloadInfo );

   117     delete iPurchaseOptionId;

   118     delete iPurchaseOptionName;

   119     delete iPurchaseOptionPrice;

   120     delete iFinalPrice;

   121     delete iPaymentMethodName;

   122     delete iDownloadedFiles;

   123     

   124     ResetAndDestroyWithCast< CNcdPurchaseInstallInfo >( iInstallInfo );

   125 

   126     delete iIcon;

   127     delete iDownloadAccessPoint;

   128     delete iDescription;

   129     delete iVersion;

   130     delete iServerUri;

   131     delete iOriginNodeId;

   132     delete iAttributes;

   133     }

   134 

   135 MNcdPurchaseDetails::TState CNcdPurchaseDetails::State() const

   136     {

   137     // The state is automatically checked here without using any

   138     // state member variable. At the moment, a member variable for 

   139     // the state and setter function for the state can not be used

   140     // because, for example, PC-client does not support it.

   141 

   142     // Notice, that here we do not use the last operation error code

   143     // to check if the last operation has failed. We just give, the current

   144     // state. It is up to the user of the purchase details to do more checking

   145     // related to the error code if more information is needed, for example, 

   146     // to check if some operation has failed and the state has not progressed

   147     // because of that.

   148     

   149     if ( iInstallInfo.Count() > 0

   150          && iInstallInfo.Count() >= iDownloadInfo.Count() )

   151         {

   152         // All the items have been installed.

   153         // So, we can suppose that the installation was a success.

   154         // So, return installed-state.

   155         return EStateInstalled;            

   156         }

   157     else if ( iDownloadedFiles 

   158               && iDownloadedFiles->Count() > 0 

   159               && iDownloadedFiles->Count() >= iDownloadInfo.Count() ) 

   160         {

   161         // All of the items have been downloaded,

   162         // So, we can suppose that the download was a success.

   163         return EStateDownloaded;            

   164         }

   165     else

   166         {

   167         // Because an item has not been yet fully downloaded or installed,

   168         // its state is purchased-state.

   169         return EStatePurchased;        

   170         }

   171     }

   172 

   173 TUid CNcdPurchaseDetails::ClientUid() const

   174     {

   175     return iClientUid;

   176     }

   177 

   178 const TDesC& CNcdPurchaseDetails::Namespace() const

   179     {

   180     return *iNamespace;

   181     }

   182 

   183 const TDesC& CNcdPurchaseDetails::EntityId() const

   184     {

   185     return *iEntityId;

   186     }

   187 

   188 const TDesC& CNcdPurchaseDetails::ItemName() const

   189     {

   190     return *iItemName;

   191     }

   192 

   193 TUint CNcdPurchaseDetails::ItemPurpose() const

   194     {

   195     return iItemPurpose;

   196     }

   197 

   198 const TDesC& CNcdPurchaseDetails::CatalogSourceName() const

   199     {

   200     return *iCatalogSourceName;

   201     }

   202 

   203 TArray< MNcdPurchaseDownloadInfo* >

   204     CNcdPurchaseDetails::DownloadInfoL() const

   205     {

   206     return iDownloadInfo.Array();

   207     }

   208 

   209 const TDesC& CNcdPurchaseDetails::PurchaseOptionId() const

   210     {

   211     return *iPurchaseOptionId;

   212     }

   213 

   214 const TDesC& CNcdPurchaseDetails::PurchaseOptionName() const

   215     {

   216     return *iPurchaseOptionName;

   217     }

   218 

   219 const TDesC& CNcdPurchaseDetails::PurchaseOptionPrice() const

   220     {

   221     return *iPurchaseOptionPrice;

   222     }

   223 

   224 const TDesC& CNcdPurchaseDetails::FinalPrice() const

   225     {

   226     return *iFinalPrice;

   227     }

   228 

   229 const TDesC& CNcdPurchaseDetails::PaymentMethodName() const

   230     {

   231     return *iPaymentMethodName;

   232     }

   233 

   234 TTime CNcdPurchaseDetails::PurchaseTime() const

   235     {

   236     return iPurchaseTime;

   237     }

   238 

   239 const MDesCArray& CNcdPurchaseDetails::DownloadedFiles() const

   240     {

   241     return *iDownloadedFiles;

   242     }

   243 

   244 TArray< MNcdPurchaseInstallInfo* > CNcdPurchaseDetails::InstallInfoL() const

   245     {

   246     return iInstallInfo.Array();

   247     }

   248 

   249 const TDesC8& CNcdPurchaseDetails::Icon() const

   250     {

   251     DASSERT( iIcon );

   252     return *iIcon;

   253     }

   254     

   255 TBool CNcdPurchaseDetails::HasIcon() const

   256     {

   257     DLTRACE(("iHasIcon: %d",iHasIcon));

   258     return iHasIcon;

   259     }

   260 

   261 const TDesC& CNcdPurchaseDetails::DownloadAccessPoint() const

   262     {

   263     return *iDownloadAccessPoint;

   264     }

   265 

   266 const TDesC& CNcdPurchaseDetails::Description() const

   267     {

   268     return *iDescription;

   269     }

   270 

   271 const TDesC& CNcdPurchaseDetails::Version() const

   272     {

   273     return *iVersion;

   274     }

   275 

   276 const TDesC& CNcdPurchaseDetails::ServerUri() const

   277     {

   278     return *iServerUri;

   279     }

   280 

   281 MNcdPurchaseDetails::TItemType CNcdPurchaseDetails::ItemType() const

   282     {

   283     return iItemType;

   284     }

   285     

   286 TInt CNcdPurchaseDetails::TotalContentSize() const 

   287     {

   288     return iTotalContentSize;

   289     }

   290     

   291 const TDesC& CNcdPurchaseDetails::OriginNodeId() const

   292     {

   293     return *iOriginNodeId;

   294     }

   295 

   296 TTime CNcdPurchaseDetails::LastOperationTime() const

   297     {

   298     return iLastOperationTime;

   299     }

   300     

   301 TInt CNcdPurchaseDetails::LastOperationErrorCode() const

   302     {

   303     return iLastOperationErrorCode;

   304     }

   305 

   306 

   307 const TDesC& CNcdPurchaseDetails::AttributeString( 

   308     TPurchaseAttribute aAttribute ) const

   309     {

   310     DLTRACEIN((""));

   311     return iAttributes->AttributeString16( aAttribute );    

   312     }

   313 

   314 

   315 TInt32 CNcdPurchaseDetails::AttributeInt32( 

   316     TPurchaseAttribute aAttribute ) const

   317     {

   318     return iAttributes->AttributeInt32( aAttribute );    

   319     }

   320 

   321 

   322 EXPORT_C void CNcdPurchaseDetails::ExternalizeL( RWriteStream& aStream ) const

   323     {

   324     TUint count = 0;

   325 

   326     aStream.WriteInt32L( iClientUid.iUid );

   327     ExternalizeDesL( *iNamespace, aStream );

   328     ExternalizeDesL( *iEntityId, aStream );

   329     ExternalizeDesL( *iItemName, aStream );

   330     aStream.WriteUint32L( iItemPurpose );

   331     ExternalizeDesL( *iCatalogSourceName, aStream );

   332     

   333     count = iDownloadInfo.Count();

   334     aStream.WriteUint32L( count );

   335     for ( TInt i = 0; i < count; i++ )

   336         {

   337         CNcdPurchaseDownloadInfo* info =

   338             (CNcdPurchaseDownloadInfo*)iDownloadInfo[i];

   339         info->ExternalizeL( aStream );

   340         }

   341         

   342     ExternalizeDesL( *iPurchaseOptionId, aStream );

   343     ExternalizeDesL( *iPurchaseOptionName, aStream );

   344     ExternalizeDesL( *iPurchaseOptionPrice, aStream );

   345     ExternalizeDesL( *iFinalPrice, aStream );

   346     ExternalizeDesL( *iPaymentMethodName, aStream );

   347     aStream << iPurchaseTime.Int64();

   348     

   349     count = iDownloadedFiles->Count();

   350     aStream.WriteUint32L( count );

   351     for ( TInt i = 0; i < count; i++ )

   352         {

   353         ExternalizeDesL( (*iDownloadedFiles)[i], aStream );

   354         }

   355         

   356     count = iInstallInfo.Count();

   357     aStream.WriteUint32L( count );

   358     for ( TInt i = 0; i < count; i++ )

   359         {

   360         CNcdPurchaseInstallInfo* info =

   361             (CNcdPurchaseInstallInfo*)iInstallInfo[i];

   362         info->ExternalizeL( aStream );

   363         }

   364 

   365     aStream.WriteInt32L( iHasIcon );

   366     ExternalizeDesL( *iIcon, aStream );

   367     ExternalizeDesL( *iDownloadAccessPoint, aStream );

   368     ExternalizeDesL( *iDescription, aStream );

   369     ExternalizeDesL( *iVersion, aStream );

   370     ExternalizeDesL( *iServerUri, aStream );

   371     aStream.WriteInt32L( iItemType );

   372     aStream.WriteInt32L( iTotalContentSize );

   373     ExternalizeDesL( *iOriginNodeId, aStream );

   374 

   375     aStream << LastOperationTime().Int64();

   376     aStream.WriteInt32L( LastOperationErrorCode() );

   377     

   378     iAttributes->ExternalizeL( aStream );

   379     }

   380 

   381 EXPORT_C void CNcdPurchaseDetails::InternalizeL( RReadStream& aStream )

   382     {

   383     TInt64 int64 = 0;

   384     TUint count = 0;

   385     

   386     iClientUid = TUid::Uid( aStream.ReadInt32L() );

   387     InternalizeDesL( iNamespace, aStream );

   388     InternalizeDesL( iEntityId, aStream );

   389     InternalizeDesL( iItemName, aStream );

   390     iItemPurpose = aStream.ReadUint32L();

   391     InternalizeDesL( iCatalogSourceName, aStream );

   392     

   393     count = aStream.ReadUint32L();

   394     for ( TInt i = 0; i < count; i++ )

   395         {

   396         CNcdPurchaseDownloadInfo* info = CNcdPurchaseDownloadInfo::NewLC();

   397         info->InternalizeL( aStream );

   398         iDownloadInfo.AppendL( info );

   399         CleanupStack::Pop( info );

   400         }

   401         

   402     InternalizeDesL( iPurchaseOptionId, aStream );

   403     InternalizeDesL( iPurchaseOptionName, aStream );

   404     InternalizeDesL( iPurchaseOptionPrice, aStream );

   405     InternalizeDesL( iFinalPrice, aStream );

   406     InternalizeDesL( iPaymentMethodName, aStream );

   407     aStream >> int64;

   408     iPurchaseTime = int64;

   409     

   410     count = aStream.ReadUint32L();

   411     for ( TInt i = 0; i < count; i++ )

   412         {

   413         HBufC* buf = NULL;

   414         InternalizeDesL( buf, aStream );

   415         CleanupStack::PushL( buf );

   416         iDownloadedFiles->AppendL( *buf );

   417         CleanupStack::PopAndDestroy( buf );

   418         }

   419 

   420     count = aStream.ReadUint32L();

   421     for ( TInt i = 0; i < count; i++ )

   422         {

   423         CNcdPurchaseInstallInfo* info = CNcdPurchaseInstallInfo::NewLC();

   424         info->InternalizeL( aStream );

   425         User::LeaveIfError( iInstallInfo.Append( info ) );

   426         CleanupStack::Pop( info );

   427         }

   428 

   429     iHasIcon = aStream.ReadInt32L();

   430     InternalizeDesL( iIcon, aStream );

   431     InternalizeDesL( iDownloadAccessPoint, aStream );

   432     InternalizeDesL( iDescription, aStream );

   433     InternalizeDesL( iVersion, aStream );

   434     InternalizeDesL( iServerUri, aStream );

   435     iItemType = (MNcdPurchaseDetails::TItemType)aStream.ReadInt32L();

   436     iTotalContentSize = aStream.ReadInt32L();

   437     InternalizeDesL( iOriginNodeId, aStream );

   438     

   439     TInt64 tmpLastOperationTime( 0 );

   440     aStream >> tmpLastOperationTime;

   441     iLastOperationTime = tmpLastOperationTime;

   442     

   443     iLastOperationErrorCode = aStream.ReadInt32L();

   444     

   445     iAttributes->InternalizeL( aStream );    

   446     }

   447 

   448 EXPORT_C void CNcdPurchaseDetails::SetClientUid( TUid aClientUid )

   449     {

   450     iClientUid = aClientUid;

   451     }

   452 

   453 EXPORT_C void CNcdPurchaseDetails::SetNamespaceL( const TDesC& aNamespace )

   454     {

   455     AssignDesL( iNamespace, aNamespace );

   456     }

   457 

   458 EXPORT_C void CNcdPurchaseDetails::SetNamespace( HBufC* aNamespace )

   459     {

   460     AssignHBufC( iNamespace, aNamespace );

   461     }

   462 

   463 EXPORT_C void CNcdPurchaseDetails::SetEntityIdL( const TDesC& aEntityId )

   464     {

   465     AssignDesL( iEntityId, aEntityId );

   466     }

   467 

   468 EXPORT_C void CNcdPurchaseDetails::SetEntityId( HBufC* aEntityId )

   469     {

   470     AssignHBufC( iEntityId, aEntityId );

   471     }

   472 

   473 EXPORT_C void CNcdPurchaseDetails::SetItemNameL( const TDesC& aItemName )

   474     {

   475     AssignDesL( iItemName, aItemName );

   476     }

   477 

   478 EXPORT_C void CNcdPurchaseDetails::SetItemName( HBufC* aItemName )

   479     {

   480     AssignHBufC( iItemName, aItemName );

   481     }

   482 

   483 EXPORT_C void CNcdPurchaseDetails::SetItemPurpose( TUint aItemPurpose )

   484     {

   485     iItemPurpose = aItemPurpose;

   486     }

   487 

   488 EXPORT_C void CNcdPurchaseDetails::SetCatalogSourceNameL(

   489     const TDesC& aCatalogSourceName )

   490     {

   491     AssignDesL( iCatalogSourceName, aCatalogSourceName );

   492     }

   493 

   494 EXPORT_C void CNcdPurchaseDetails::SetCatalogSourceName( HBufC* aCatalogSourceName )

   495     {

   496     AssignHBufC( iCatalogSourceName, aCatalogSourceName );

   497     }

   498 

   499 EXPORT_C void CNcdPurchaseDetails::SetDownloadInfoL(

   500     const TArray< MNcdPurchaseDownloadInfo* >& aDownloadInfo )

   501     {

   502     DLTRACEIN((""));

   503     

   504     RPointerArray< MNcdPurchaseDownloadInfo > tempArray;

   505     // Can't push to cleanup stack since MNcdPurchaseDownloadInfo cannot be

   506     // deleted but the array owns the objects

   507     

   508     TRAPD( err, 

   509         {

   510         TInt count = aDownloadInfo.Count();

   511         tempArray.ReserveL( count );

   512         for ( TInt i = 0; i < count; i++ )

   513             {

   514             CNcdPurchaseDownloadInfo* info =

   515                 CNcdPurchaseDownloadInfo::NewLC( *aDownloadInfo[i] );

   516             tempArray.AppendL( info );

   517             CleanupStack::Pop( info );

   518             }

   519         });

   520     if ( err != KErrNone ) 

   521         {

   522         DLERROR(("%d", err));

   523         ResetAndDestroyWithCast<CNcdPurchaseDownloadInfo>( tempArray );

   524         User::Leave( err );

   525         }

   526         

   527     ResetAndDestroyWithCast<CNcdPurchaseDownloadInfo>( iDownloadInfo );

   528     iDownloadInfo = tempArray;

   529     }

   530 

   531 

   532 

   533 EXPORT_C void CNcdPurchaseDetails::AddDownloadInfoL( 

   534     MNcdPurchaseDownloadInfo* aDownloadInfo )

   535     {

   536     iDownloadInfo.AppendL( aDownloadInfo );

   537     }

   538 

   539 

   540 EXPORT_C void CNcdPurchaseDetails::InsertDownloadInfoL( 

   541     MNcdPurchaseDownloadInfo* aDownloadInfo, 

   542     TInt aIndex )

   543     {

   544     iDownloadInfo.InsertL( aDownloadInfo, aIndex );

   545     }

   546 

   547 

   548 EXPORT_C void CNcdPurchaseDetails::RemoveDownloadInfo( TInt aIndex )

   549     {

   550     DeleteFromArray<CNcdPurchaseDownloadInfo>( iDownloadInfo, aIndex );

   551     }

   552     

   553     

   554 EXPORT_C TInt CNcdPurchaseDetails::DownloadInfoCount() const

   555     {

   556     return iDownloadInfo.Count();

   557     }

   558     

   559     

   560 EXPORT_C CNcdPurchaseDownloadInfo& CNcdPurchaseDetails::DownloadInfo(

   561     TInt aIndex )

   562     {

   563     CNcdPurchaseDownloadInfo* ptr = static_cast<CNcdPurchaseDownloadInfo*>(

   564         iDownloadInfo[aIndex] );

   565     return *ptr;

   566     }

   567     

   568 

   569 EXPORT_C void CNcdPurchaseDetails::SetPurchaseOptionIdL(

   570     const TDesC& aPurchaseOptionId )

   571     {

   572     AssignDesL( iPurchaseOptionId, aPurchaseOptionId );

   573     }

   574 

   575 EXPORT_C void CNcdPurchaseDetails::SetPurchaseOptionId( HBufC* aPurchaseOptionId )

   576     {

   577     AssignHBufC( iPurchaseOptionId, aPurchaseOptionId );

   578     }

   579 

   580 EXPORT_C void CNcdPurchaseDetails::SetPurchaseOptionNameL(

   581     const TDesC& aPurchaseOptionName )

   582     {

   583     AssignDesL( iPurchaseOptionName, aPurchaseOptionName );

   584     }

   585 

   586 EXPORT_C void CNcdPurchaseDetails::SetPurchaseOptionName( HBufC* aPurchaseOptionName )

   587     {

   588     AssignHBufC( iPurchaseOptionName, aPurchaseOptionName );

   589     }

   590 

   591 EXPORT_C void CNcdPurchaseDetails::SetPurchaseOptionPriceL(

   592     const TDesC& aPurchaseOptionPrice )

   593     {

   594     AssignDesL( iPurchaseOptionPrice, aPurchaseOptionPrice );

   595     }

   596 

   597 EXPORT_C void CNcdPurchaseDetails::SetPurchaseOptionPrice(

   598     HBufC* aPurchaseOptionPrice )

   599     {

   600     AssignHBufC( iPurchaseOptionPrice, aPurchaseOptionPrice );

   601     }

   602 

   603 EXPORT_C void CNcdPurchaseDetails::SetFinalPriceL( const TDesC& aFinalPrice )

   604     {

   605     AssignDesL( iFinalPrice, aFinalPrice );

   606     }

   607 

   608 EXPORT_C void CNcdPurchaseDetails::SetFinalPrice( HBufC* aFinalPrice )

   609     {

   610     AssignHBufC( iFinalPrice, aFinalPrice );

   611     }

   612 

   613 EXPORT_C void CNcdPurchaseDetails::SetPaymentMethodNameL(

   614     const TDesC& aPaymentMethodName )

   615     {

   616     AssignDesL( iPaymentMethodName, aPaymentMethodName );

   617     }

   618 

   619 EXPORT_C void CNcdPurchaseDetails::SetPaymentMethodName( HBufC* aPaymentMethodName )

   620     {

   621     AssignHBufC( iPaymentMethodName, aPaymentMethodName );

   622     }

   623 

   624 EXPORT_C void CNcdPurchaseDetails::SetPurchaseTime( TTime aPurchaseTime )

   625     {

   626     iPurchaseTime = aPurchaseTime;

   627     }

   628 

   629 EXPORT_C void CNcdPurchaseDetails::SetDownloadedFiles( CDesCArray* aDownloadedFiles )

   630     {

   631     delete iDownloadedFiles;

   632     iDownloadedFiles = aDownloadedFiles;

   633     }

   634 

   635 EXPORT_C void CNcdPurchaseDetails::SetDownloadedFilesL(

   636     const MDesCArray& aDownloadedFiles )

   637     {

   638     delete iDownloadedFiles;

   639     iDownloadedFiles = NULL;

   640     iDownloadedFiles = new (ELeave) CDesCArrayFlat( KListGranularity );

   641     for ( TInt i = 0; i < aDownloadedFiles.MdcaCount(); i++ )

   642         {

   643         iDownloadedFiles->AppendL( aDownloadedFiles.MdcaPoint( i ) );

   644         }

   645     }

   646 

   647 

   648 EXPORT_C void CNcdPurchaseDetails::ReplaceDownloadedFileL( TInt aIndex, 

   649     const TDesC& aDownloadedFile )

   650     {    

   651     iDownloadedFiles->InsertL( aIndex, aDownloadedFile );

   652     iDownloadedFiles->Delete( aIndex + 1 );

   653     }

   654     

   655 

   656 EXPORT_C void CNcdPurchaseDetails::AddDownloadedFileL( 

   657     const TDesC& aDownloadedFile )

   658     {

   659     iDownloadedFiles->AppendL( aDownloadedFile );

   660     }

   661 

   662 EXPORT_C void CNcdPurchaseDetails::InsertDownloadedFileL( 

   663     const TDesC& aDownloadedFile, 

   664     TInt aIndex )

   665     {

   666     iDownloadedFiles->InsertL( aIndex, aDownloadedFile );

   667     }

   668 

   669 

   670 EXPORT_C void CNcdPurchaseDetails::RemoveDownloadedFile( 

   671     TInt aIndex )

   672     {

   673     iDownloadedFiles->Delete( aIndex );

   674     }

   675     

   676 

   677 EXPORT_C void CNcdPurchaseDetails::SetInstallInfoL(

   678     const TArray< MNcdPurchaseInstallInfo* >& aInstallInfo )

   679     {

   680     DLTRACEIN((""));

   681     RPointerArray<MNcdPurchaseInstallInfo> tempArray;

   682     

   683     TRAPD( err, 

   684         {            

   685         TInt count = aInstallInfo.Count();

   686         tempArray.ReserveL( count );

   687         

   688         for ( TInt i = 0; i < count; i++ )

   689             {

   690             CNcdPurchaseInstallInfo* info =

   691                 CNcdPurchaseInstallInfo::NewLC( *aInstallInfo[i] );

   692             tempArray.AppendL( info );

   693             CleanupStack::Pop( info );

   694             }

   695         });

   696     

   697     if ( err != KErrNone )

   698         {

   699         DLERROR(("%d", err));

   700         ResetAndDestroyWithCast<CNcdPurchaseInstallInfo>( tempArray );    

   701         User::Leave( err );

   702         }

   703         

   704     ResetAndDestroyWithCast<CNcdPurchaseInstallInfo>( iInstallInfo );

   705     iInstallInfo = tempArray;

   706     }

   707 

   708 

   709 EXPORT_C void CNcdPurchaseDetails::AddInstallInfoL( 

   710     MNcdPurchaseInstallInfo* aInstallInfo )

   711     {

   712     iInstallInfo.AppendL( aInstallInfo );

   713     }

   714 

   715 

   716 EXPORT_C void CNcdPurchaseDetails::InsertInstallInfoL( 

   717     MNcdPurchaseInstallInfo* aInstallInfo,

   718     TInt aIndex )

   719     {

   720     iInstallInfo.InsertL( aInstallInfo, aIndex );

   721     }

   722 

   723 

   724 EXPORT_C void CNcdPurchaseDetails::RemoveInstallInfo( TInt aIndex )

   725     {

   726     DeleteFromArray<CNcdPurchaseInstallInfo>( iInstallInfo, aIndex );

   727     }

   728     

   729 

   730 EXPORT_C TInt CNcdPurchaseDetails::InstallInfoCount() const

   731     {

   732     return iInstallInfo.Count();

   733     }

   734     

   735     

   736 EXPORT_C CNcdPurchaseInstallInfo& CNcdPurchaseDetails::InstallInfo( 

   737     TInt aIndex )

   738     {

   739     DASSERT( aIndex >= 0 && aIndex < iInstallInfo.Count() );

   740     CNcdPurchaseInstallInfo* ptr = static_cast<CNcdPurchaseInstallInfo*>( 

   741         iInstallInfo[aIndex] );

   742     return *ptr;

   743     }

   744     

   745 

   746 EXPORT_C void CNcdPurchaseDetails::SetIconL( const TDesC8& aIcon )

   747     {

   748     HBufC8* tmpIcon = aIcon.AllocL();

   749     delete iIcon;

   750     iIcon = tmpIcon;

   751     iHasIcon = ETrue;

   752     }

   753 

   754 EXPORT_C void CNcdPurchaseDetails::SetIcon( HBufC8* aIcon )

   755     {

   756     delete iIcon;

   757     iIcon = aIcon;

   758     iHasIcon = ETrue;

   759     }

   760     

   761 EXPORT_C HBufC8* CNcdPurchaseDetails::GetIconData()

   762     {

   763     HBufC8* tmpIcon = iIcon;

   764     iIcon = NULL;

   765     return tmpIcon;

   766     }

   767     

   768 EXPORT_C void CNcdPurchaseDetails::SetHasIcon( TBool aHasIcon )

   769     {

   770     iHasIcon = aHasIcon;

   771     }

   772     

   773 EXPORT_C void CNcdPurchaseDetails::SetDownloadAccessPointL(

   774     const TDesC& aAccessPoint )

   775     {

   776     AssignDesL( iDownloadAccessPoint, aAccessPoint );

   777     }

   778 

   779 EXPORT_C void CNcdPurchaseDetails::SetDownloadAccessPoint(

   780     HBufC* aAccessPoint )

   781     {

   782     AssignHBufC( iDownloadAccessPoint, aAccessPoint );

   783     }

   784 

   785 EXPORT_C void CNcdPurchaseDetails::SetDescriptionL(

   786     const TDesC& aDescription )

   787     {

   788     AssignDesL( iDescription, aDescription );

   789     }

   790 

   791 EXPORT_C void CNcdPurchaseDetails::SetDescription(

   792     HBufC* aDescription )

   793     {

   794     AssignHBufC( iDescription, aDescription );

   795     }

   796 

   797 EXPORT_C void CNcdPurchaseDetails::SetVersionL(

   798     const TDesC& aVersion )

   799     {

   800     AssignDesL( iVersion, aVersion );

   801     }

   802 

   803 EXPORT_C void CNcdPurchaseDetails::SetVersion(

   804     HBufC* aVersion )

   805     {

   806     AssignHBufC( iVersion, aVersion );

   807     }

   808 

   809 EXPORT_C void CNcdPurchaseDetails::SetServerUriL(

   810     const TDesC& aServerUri )

   811     {

   812     AssignDesL( iServerUri, aServerUri );

   813     }

   814 

   815 EXPORT_C void CNcdPurchaseDetails::SetServerUri(

   816     HBufC* aServerUri )

   817     {

   818     AssignHBufC( iServerUri, aServerUri );

   819     }

   820 

   821 EXPORT_C void CNcdPurchaseDetails::SetItemType(

   822     TItemType aItemType )

   823     {

   824     iItemType = aItemType;

   825     }

   826     

   827 EXPORT_C void CNcdPurchaseDetails::SetTotalContentSize( TInt aSize )

   828     {

   829     iTotalContentSize = aSize;

   830     }

   831     

   832 EXPORT_C void CNcdPurchaseDetails::SetOriginNodeIdL( const TDesC& aOriginNodeId )

   833     {

   834     AssignDesL( iOriginNodeId, aOriginNodeId );

   835     }

   836     

   837 EXPORT_C void CNcdPurchaseDetails::SetOriginNodeId( HBufC* aOriginNodeId )

   838     {

   839     AssignHBufC( iOriginNodeId, aOriginNodeId );

   840     }

   841 

   842 EXPORT_C void CNcdPurchaseDetails::SetLastUniversalOperationTime()

   843     {

   844     TTime time;

   845     time.UniversalTime();

   846     SetLastOperationTime( time );

   847     }

   848 

   849 EXPORT_C void CNcdPurchaseDetails::SetLastOperationTime( const TTime& aTime )

   850     {

   851     iLastOperationTime = aTime;

   852     }

   853     

   854 EXPORT_C void CNcdPurchaseDetails::SetLastOperationErrorCode( TInt aError )

   855     {

   856     iLastOperationErrorCode = aError;

   857     }

   858 

   859 

   860 EXPORT_C void CNcdPurchaseDetails::SetAttributeL( 

   861     TPurchaseAttribute aAttribute, 

   862     TInt32 aValue )

   863     {    

   864     iAttributes->SetAttributeL( aAttribute, aValue );

   865     }

   866 

   867 

   868 EXPORT_C void CNcdPurchaseDetails::SetAttributeL( 

   869     TPurchaseAttribute aAttribute, 

   870     const TDesC& aValue )

   871     {    

   872     iAttributes->SetAttributeL( aAttribute, aValue );

   873     }

   874 

   875 EXPORT_C void CNcdPurchaseDetails::ExternalizeAttributesL( 

   876     RWriteStream& aStream ) const

   877     {

   878     DLTRACEIN((""));

   879     iAttributes->ExternalizeL( aStream );

   880     }

   881 

   882 EXPORT_C void CNcdPurchaseDetails::InternalizeAttributesL( 

   883     RReadStream& aStream )

   884     {

   885     DLTRACEIN((""));

   886     iAttributes->InternalizeL( aStream );

   887     }

   888 

   889 

   890 void CNcdPurchaseDetails::CreateAttributesL()

   891     {

   892     DLTRACEIN((""));

   893     if ( !iAttributes ) 

   894         {

   895         iAttributes = CNcdAttributes::NewL( 

   896             MNcdPurchaseDetails::EPurchaseAttributeInternal );

   897         }

   898     }

   899 

   900 

   901 void CNcdPurchaseDetails::ConstructL()

   902     {

   903     iNamespace = KNullDesC().AllocL();

   904     iEntityId = KNullDesC().AllocL();

   905     iItemName = KNullDesC().AllocL();

   906     iCatalogSourceName = KNullDesC().AllocL();

   907     iPurchaseOptionId = KNullDesC().AllocL();

   908     iPurchaseOptionName = KNullDesC().AllocL();

   909     iPurchaseOptionPrice = KNullDesC().AllocL();

   910     iFinalPrice = KNullDesC().AllocL();

   911     iPaymentMethodName = KNullDesC().AllocL();

   912     iDownloadedFiles = new (ELeave) CDesCArrayFlat( KListGranularity );

   913     iIcon = KNullDesC8().AllocL();

   914     iDownloadAccessPoint = KNullDesC().AllocL();

   915     iDescription = KNullDesC().AllocL();

   916     iVersion = KNullDesC().AllocL();

   917     iServerUri = KNullDesC().AllocL();

   918     iItemType = MNcdPurchaseDetails::EItem;

   919     iOriginNodeId = KNullDesC().AllocL();

   920     CreateAttributesL();

   921     }

   922 

   923 CNcdPurchaseDetails::CNcdPurchaseDetails()

   924     : iPurchaseTime( 0 ),

   925       iHasIcon( EFalse ), 

   926       iTotalContentSize( 0 ), 

   927       iLastOperationTime( 0 ),

   928       iLastOperationErrorCode( KErrNone )

   929       

   930     {

   931     iClientUid = TUid::Null();

   932     }