/*

* 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 CNcdNodeDownload class

*

*/

#include <bautils.h>

#include "ncdnodedownloadimpl.h"

#include "catalogssession.h"

#include "catalogsbasemessage.h"

#include "ncdnodefunctionids.h"

#include "ncdnodeclassids.h"

#include "ncdpurchasedetails.h"

#include "ncdutils.h"

#include "catalogsconstants.h"

#include "ncd_pp_dataentity.h"

#include "ncd_cp_query.h"

#include "catalogsutils.h"

#include "catalogsdebug.h"

#include "ncdproviderutils.h"

CNcdNodeDownload::CNcdNodeDownload( NcdNodeClassIds::TNcdNodeClassId aClassId )

: CCatalogsCommunicable(),

  iClassId( aClassId )

    {

    }

void CNcdNodeDownload::ConstructL()

    {

    }

CNcdNodeDownload* CNcdNodeDownload::NewL()

    {

    CNcdNodeDownload* self =   

        CNcdNodeDownload::NewLC();

    CleanupStack::Pop( self );

    return self;        

    }

CNcdNodeDownload* CNcdNodeDownload::NewLC()

    {

    CNcdNodeDownload* self = 

        new( ELeave ) CNcdNodeDownload( 

            NcdNodeClassIds::ENcdNodeDownloadClassId );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;        

    }

CNcdNodeDownload::~CNcdNodeDownload()

    {

    DLTRACEIN((""));

    // Delete member variables here.

    TInt count = iDownloadInfo.Count();

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

        {

        CNcdPurchaseDownloadInfo* info =

            static_cast<CNcdPurchaseDownloadInfo*>(iDownloadInfo[i]);

        delete info;

        info = NULL;

        }

    iDownloadInfo.Reset();

    delete iFiles;

    DLTRACEOUT((""));

    }        

NcdNodeClassIds::TNcdNodeClassId CNcdNodeDownload::ClassId() const

    {

    return iClassId;

    }

// Internalization from the purchase history.

TBool CNcdNodeDownload::InternalizeL( const MNcdPurchaseDetails& aDetails )

    {

    DLTRACEIN(("this-ptr: %X", this));

    TArray<MNcdPurchaseDownloadInfo*> dlInfos( aDetails.DownloadInfoL() );

    TInt count = dlInfos.Count();    

    // Quit if no download data exists or it's consumable

    if ( count == 0 || ( count == 1 && 

         dlInfos[0]->ContentUsage() == 

         MNcdPurchaseDownloadInfo::EConsumable ))

        {

        // No download data found from purchase details.

        DLTRACEOUT((""));

        return EFalse;

        }

    // Check for any downloadable URIs

    TBool uriExists = EFalse;

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

        {

        if ( dlInfos[i]->ContentUri().Length() ||

             dlInfos[i]->DescriptorUri().Length() ||

             dlInfos[i]->DescriptorData().Length() ||

             dlInfos[i]->RightsUri().Length() )

            {

            uriExists = ETrue;

            break;

            }

        }

    if ( !uriExists ) 

        {

        DLTRACEOUT(("No URI, no download API"));

        return EFalse;

        }

    iIsDownloaded = EFalse;

    delete iFiles;

    iFiles = NULL;

    iFiles = new (ELeave) CDesCArrayFlat( KListGranularity );

    RPointerArray<MNcdPurchaseDownloadInfo> tempInfos;

    // Can't use CleanupResetAndDestroyPushL because the array can't

    // be deleted with ResetAndDestroy

    TRAPD( err, 

        {

        tempInfos.ReserveL( count );

        DLTRACE(("Copying purchase download infos"));

        // Download data found from purchase details.

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

            {

            CNcdPurchaseDownloadInfo* info =

                CNcdPurchaseDownloadInfo::NewLC( *dlInfos[i] );

            tempInfos.AppendL( info );

            CleanupStack::Pop( info );

            }

        // Check purchase details status.

        if ( aDetails.State() == MNcdPurchaseDetails::EStateDownloaded ||

             aDetails.State() == MNcdPurchaseDetails::EStateInstalled )

            {

            iIsDownloaded = ETrue;

            DLTRACE(("Copy file paths, iIsDownloaded = ETrue"));

            const MDesCArray& files( aDetails.DownloadedFiles() );

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

                {

                iFiles->AppendL( files.MdcaPoint( i ) );

                }

            }

        ResetAndDestroyWithCast<CNcdPurchaseDownloadInfo>( iDownloadInfo );

        iDownloadInfo = tempInfos;

        });

    if ( err != KErrNone ) 

        {

        ResetAndDestroyWithCast<CNcdPurchaseDownloadInfo>( tempInfos );

        }

    DLTRACEOUT(("iIsDownloaded: %d", iIsDownloaded));

    return ETrue;

    }

const RPointerArray< MNcdPurchaseDownloadInfo >&

    CNcdNodeDownload::DownloadInfo() const

    {

    return iDownloadInfo;

    }

void CNcdNodeDownload::ReceiveMessage( MCatalogsBaseMessage* aMessage,

                                       TInt aFunctionNumber )

    {

    DLTRACEIN(("this-ptr: %X", this));    

    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;

        case NcdNodeFunctionIds::ENcdFilesExist:

            TRAP( trapError, FilesExistRequestL( *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 CNcdNodeDownload::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 CNcdNodeDownload::InternalizeRequestL( MCatalogsBaseMessage& aMessage )

    {

    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, ReceiveMessage will complete the message.

    // NOTE: that here we expect that the buffer contains at least

    // some data. So, make sure that ExternalizeDataForRequestL inserts

    // something to the buffer.

    aMessage.CompleteAndReleaseL( buf->Ptr( 0 ), KErrNone );        

    DLTRACE(("Deleting the buf"));

    CleanupStack::PopAndDestroy( buf );

    DLTRACEOUT((""));

    }

void CNcdNodeDownload::ExternalizeDataForRequestL( RWriteStream& aStream )

    {

    DLTRACEIN((""));

    // Download existed. So, insert info that meta data was found.

    aStream.WriteInt32L( ClassId() );

    // Add additional content to the stream.

    // Make sure that this matches to the order that is used in the proxy

    // side when this stream is internalized.

    // NOTE: Be careful with the 8- and 16-bit descriptors. Remember to check

    // if the proxy wants the data in 16 or 8 bits?    

    aStream.WriteInt32L( iIsDownloaded );

    DLTRACEOUT(("iIsDownloaded: %d", iIsDownloaded ));

    }

void CNcdNodeDownload::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 CNcdNodeDownload::FilesExistRequestL( MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    TBool filesExist = EFalse;

    if ( iIsDownloaded )

        {

        filesExist = FilesExist();

        }

    // If this leaves, ReceiveMessage will complete the message.

    // NOTE: that here we expect that the buffer contains at least

    // some data. So, make sure that ExternalizeDataForRequestL inserts

    // something to the buffer.

    aMessage.CompleteAndReleaseL( filesExist, KErrNone );        

    DLTRACEOUT(("filesExist: %d", filesExist));

    }

TBool CNcdNodeDownload::FilesExist()

    {

    DLTRACEIN((""));

    DASSERT( iFiles->MdcaCount() == iDownloadInfo.Count() );

    for ( TInt i = 0; i < iFiles->MdcaCount(); ++i )

        {        

        TInt shouldExist = 1;        

        // AttributeInt32L leaves only with KErrNone and that happens

        // if the attribute is not set which means that that download

        // is required

        TRAP_IGNORE( shouldExist = iDownloadInfo[i]->AttributeInt32L( 

            MNcdPurchaseDownloadInfo::EDownloadAttributeRequiredDownload ) );

        if ( !iDownloadInfo[i]->ContentUri().Length() ) 

            {

            DLTRACE(("No URI, no file"));

            shouldExist = EFalse;

            }

        DLTRACE(("Downloaded file should exist: %d", shouldExist));        

        // Dependencies and in Get-cases content file don't have to be

        // downloaded because they can already be installed. In those cases

        // shouldExist == 0 and this check is skipped

        if ( shouldExist && (

             iFiles->MdcaPoint( i ).Length() == 0 ||

             !BaflUtils::FileExists( 

                CNcdProviderUtils::FileSession(),

                iFiles->MdcaPoint( i ) ) ) )

            {            

            return EFalse;

            }            

        }

    return ETrue;

    }