/*

* 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:   Contains CNcdNodeDownloadProxy class implementation

*

*/

#include "ncdnodedownloadproxy.h"

#include "ncdnodemetadataproxy.h"

#include "ncdnodeproxy.h"

#include "ncdoperationimpl.h"

#include "ncddownloadoperationproxy.h"

#include "ncdoperationmanagerproxy.h"

#include "ncdoperationdatatypes.h"

#include "catalogsclientserver.h"

#include "ncdnodeidentifier.h"

#include "ncdnodefunctionids.h"

#include "ncdnodeclassids.h"

#include "catalogsinterfaceidentifier.h"

#include "catalogsutils.h"

#include "catalogsdebug.h"

// ======== PUBLIC MEMBER FUNCTIONS ========

CNcdNodeDownloadProxy::CNcdNodeDownloadProxy(

    MCatalogsClientServer& aSession,

    TInt aHandle,

    CNcdNodeMetadataProxy& aMetadata )

: CNcdInterfaceBaseProxy( aSession, aHandle, &aMetadata ),

  iMetadata( aMetadata )

    {

    }

void CNcdNodeDownloadProxy::ConstructL()

    {

    // Register the interface

    MNcdNodeDownload* interface( this );

    AddInterfaceL( 

        CCatalogsInterfaceIdentifier::NewL( interface, this, MNcdNodeDownload::KInterfaceUid ) );

    InternalizeL();

    }

CNcdNodeDownloadProxy* CNcdNodeDownloadProxy::NewL(

    MCatalogsClientServer& aSession,

    TInt aHandle,

    CNcdNodeMetadataProxy& aMetadata )

    {

    CNcdNodeDownloadProxy* self = 

        CNcdNodeDownloadProxy::NewLC( aSession, aHandle, aMetadata );

    CleanupStack::Pop( self );

    return self;

    }

CNcdNodeDownloadProxy* CNcdNodeDownloadProxy::NewLC(

    MCatalogsClientServer& aSession,

    TInt aHandle,

    CNcdNodeMetadataProxy& aMetadata )

    {

    CNcdNodeDownloadProxy* self = 

        new( ELeave ) CNcdNodeDownloadProxy( aSession, aHandle, aMetadata );

    // Using PushL because the object does not have any references yet

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CNcdNodeDownloadProxy::~CNcdNodeDownloadProxy()

    {

    DLTRACEIN((""));

    // Remove interfaces implemented by this class from the interface list.

    // So, the interface list is up to date when this class object is deleted.

    RemoveInterface( MNcdNodeDownload::KInterfaceUid );

    // Delete member variables here

    // Do not delete node and operation manager because

    // this object does not own them.

    }

CNcdNodeMetadataProxy& CNcdNodeDownloadProxy::Metadata() const

    {

    return iMetadata;

    }

void CNcdNodeDownloadProxy::InternalizeL()

    {

    DLTRACEIN((""));

    HBufC8* data( NULL );

    // Because we do not know the exact size of the data, use

    // the alloc method, which creates the buffer of the right size

    // and sets the pointer to point to the created buffer.

    // Get all the data that is necessary to internalize this object

    // from the server side.

    User::LeaveIfError(

        ClientServerSession().

        SendSyncAlloc( NcdNodeFunctionIds::ENcdInternalize,

                       KNullDesC8,

                       data,

                       Handle(),

                       0 ) );

    if ( data == NULL )

        {

        DLERROR((""));

        User::Leave(  KErrNotFound );

        }

     CleanupStack::PushL( data );

     // Read the data from the stream and insert it to the memeber variables

     RDesReadStream stream( *data );

     CleanupClosePushL( stream );

     InternalizeDataL( stream );

     // Closes the stream

     CleanupStack::PopAndDestroy( &stream ); 

     CleanupStack::PopAndDestroy( data );

    DLTRACEOUT((""));    

    }

// MNcdNodeDownload functions

TBool CNcdNodeDownloadProxy::IsDownloadedL() const

    {

    DLTRACEIN((""));

    if ( !iIsDownloaded )

        {

        DLTRACEOUT(("iIsDownloaded == EFalse"));

        return EFalse;

        }

    TInt filesExist = 0;

    // Internalize so that the server checks whether the files exist or not

    User::LeaveIfError(

        ClientServerSession().

        SendSync( NcdNodeFunctionIds::ENcdFilesExist,

                       KNullDesC8,

                       filesExist,

                       Handle() ) );

    DLTRACEOUT(("isDownloaded status from server: %d", filesExist ));

    return filesExist;

    }

MNcdDownloadOperation* CNcdNodeDownloadProxy::DownloadContentL( 

    MNcdDownloadOperationObserver& aObserver )

    {

    DLTRACEIN((""));    

    CNcdDownloadOperationProxy* operation( NULL );

    // What is the data id here? Is KNullDesC ok?

    operation = 

        Metadata().Node().

        OperationManager().

        CreateDownloadOperationL( ENcdContentDownload, 

                                  Metadata().Node(),

                                  KNullDesC, 

                                  &aObserver );

    // It is enought that the observer is informed

    // when the file operation is ready. So, no need to add

    // node or this class object to be observers.

    // No need to increase the operation ref count here because

    // it should be initially one.

    DLTRACEOUT(("Operation %x", 

        static_cast<MCatalogsBase*>( operation ) ));    

    return operation;

    }

// Other functions

void CNcdNodeDownloadProxy::InternalizeDataL( RReadStream& aStream )

    {

    DLTRACEIN((""));

    // Use catalogsutils.h functions to internalize

    // memebervariables according to the data received

    // from the server.

    // Make sure that the variables are set here in the same

    // order as they are externalized in the server side.

    // Small mistake here messes up everything!

    // First read the class id. Because, it is the first thing in the stream.

    TInt classId( aStream.ReadInt32L() );

    if ( classId != NcdNodeClassIds::ENcdNodeDownloadClassId )

        {

        // classId is not recognized

        DLERROR(("Class id was not recognized!"));

        // For testing purposes assert here

        DASSERT( EFalse );

        // Otherwise leave is adequate

        User::Leave( KErrCorrupt );

        }

    iIsDownloaded = aStream.ReadInt32L();

    DLTRACEOUT((""));

    }