/*

* 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 CNcdFileDownloadOperationProxy

*

*/

#include <s32strm.h>

#include "ncdfiledownloadoperationproxy.h"

#include "ncdfiledownloadoperationobserver.h"

#include "catalogsdebug.h"

#include "ncddownloadoperationstates.h"

#include "ncdoperationproxyremovehandler.h"

#include "catalogsclientserver.h"

#include "catalogsutils.h"

#include "ncdnodeproxy.h"

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

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//

CNcdFileDownloadOperationProxy* CNcdFileDownloadOperationProxy::NewL( 

    MCatalogsClientServer& aSession,

    TInt aHandle,

    MNcdOperationProxyRemoveHandler* aRemoveHandler,

    CNcdNodeProxy* aNode,

    CNcdNodeManagerProxy* aNodeManager,

    const TDesC& aTargetFilename,

    MNcdFileDownloadOperationObserver* aObserver,

    TNcdDownloadDataType aDataType )

    {

    CNcdFileDownloadOperationProxy* self = 

        CNcdFileDownloadOperationProxy::NewLC( 

        aSession,

        aHandle,

        aRemoveHandler,

        aNode,

        aNodeManager,

        aTargetFilename,

        aObserver,

        aDataType );

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// NewLC

// ---------------------------------------------------------------------------

//

CNcdFileDownloadOperationProxy* CNcdFileDownloadOperationProxy::NewLC( 

    MCatalogsClientServer& aSession,

    TInt aHandle,

    MNcdOperationProxyRemoveHandler* aRemoveHandler,

    CNcdNodeProxy* aNode,

    CNcdNodeManagerProxy* aNodeManager,

    const TDesC& aTargetFilename,

    MNcdFileDownloadOperationObserver* aObserver,

    TNcdDownloadDataType aDataType )

    {

    CNcdFileDownloadOperationProxy* self =

        new( ELeave ) CNcdFileDownloadOperationProxy( aDataType );    

    self->AddRef();

    CleanupReleasePushL( *self );        

    self->ConstructL( aSession, aHandle, aRemoveHandler,

        aNode, aNodeManager, aObserver, aTargetFilename );

    return self;

    }

// ---------------------------------------------------------------------------

// From MNcdFileDownloadOperation

// 

// ---------------------------------------------------------------------------

//

const TDesC& CNcdFileDownloadOperationProxy::TargetFileName() const

    {

    DASSERT( iTargetFilename );

    return *iTargetFilename;

    }

// ---------------------------------------------------------------------------

// From MNcdFileDownloadOperation

// 

// ---------------------------------------------------------------------------

//

void CNcdFileDownloadOperationProxy::PauseL()

    {

    DLTRACEIN( ( "" ) );

    HBufC8* data = NULL;

    TState state = OperationStateL();

    // Check that the operation is in a resumable state    

    if ( state == EStateCancelled ) 

        {

        DLERROR(("Cannot resume! Operation has been cancelled. Leaving"));

        User::Leave( KErrCancel );

        }

    // Operation must be running for pause to work    

    if ( state != EStateRunning || iIsPaused ) 

        {     

        DLTRACEOUT(("Operation complete or other unresumable state"));   

        return;

        }    

    ClientServerSession().SendSyncAlloc( ENCDOperationFunctionPause,

        KNullDesC8(),

        data,

        Handle(),

        0 );

    if ( data ) 

        {

        DLTRACE(("Received progress information"));

        RDesReadStream stream( *data );

        CleanupStack::PushL( data );

        CleanupClosePushL( stream );

        // Just read completionId from the stream

        stream.ReadInt32L();

        TNcdSendableProgress progress;

        // Read progress info

        progress.InternalizeL( stream );

        // Update paused state

        iIsPaused = ( progress.iState == ENcdDownloadPaused );        

        CleanupStack::PopAndDestroy( 2, data ); // stream, data        

        }

    SetState( EStateRunning );     

    DLTRACEOUT( ( "IsPaused: %d", iIsPaused ) );    

    }

// ---------------------------------------------------------------------------

// From MNcdFileDownloadOperation

// 

// ---------------------------------------------------------------------------

//

void CNcdFileDownloadOperationProxy::ResumeL()

    {

    DLTRACEIN(( "" ));

    HBufC8* data = NULL;

    TState state = OperationStateL();

    // Check that the operation is in a resumable state    

    if ( state == EStateCancelled ) 

        {

        DLERROR(("Cannot resume! Operation has been cancelled. Leaving"));

        User::Leave( KErrCancel );

        }

    if ( ( state != EStateStopped && state != EStateRunning ) || !iIsPaused )

        {     

        DLTRACEOUT(("Operation complete or other unresumable state"));   

        return;

        }

    ClientServerSession().SendSyncAlloc( ENCDOperationFunctionResume,

        KNullDesC8(),

        data,

        Handle(),

        0 );

    if ( data ) 

        {

        DLTRACE(("Received progress information"));

        RDesReadStream stream( *data );

        CleanupStack::PushL( data );

        CleanupClosePushL( stream );

        // Just read the completionId from the stream

        stream.ReadInt32L();

        TNcdSendableProgress progress;

        // Read progress info

        progress.InternalizeL( stream );

        // Update paused-state

        iIsPaused = ( progress.iState == ENcdDownloadPaused );

        DLTRACE(("Sending continue message"));

        if ( progress.iState == KNcdDownloadContinueMessageRequired  )

            {

            SendContinueMessageL();

            }        

        CleanupStack::PopAndDestroy( 2, data ); // stream, data        

        }

    SetState( EStateRunning );     

    DLTRACEOUT(( "" ));

    }

// ---------------------------------------------------------------------------

// From MNcdFileDownloadOperation

// 

// ---------------------------------------------------------------------------

//

TBool CNcdFileDownloadOperationProxy::IsPaused()

    {

    return iIsPaused;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

TBool CNcdFileDownloadOperationProxy::IsPausableL()

    {

    DLTRACEIN((""));

    TInt data = KErrNone;

    User::LeaveIfError( ClientServerSession().SendSync( 

        ENCDOperationFunctionGetData,

        KNullDesC8(),

        data,

        Handle() ) );

    DLTRACEOUT(("pausable: %d", data == KNcdDownloadIsPausable ));

    return data == KNcdDownloadIsPausable;

    }

// ---------------------------------------------------------------------------

// Download type getter

// ---------------------------------------------------------------------------

//

TNcdDownloadDataType CNcdFileDownloadOperationProxy::DownloadDataType() const

    {

    return iDataType;

    }

// ---------------------------------------------------------------------------

// From MNcdOperation

// Operation type getter

// ---------------------------------------------------------------------------

//

TNcdInterfaceId CNcdFileDownloadOperationProxy::OperationType() const

    {

    return static_cast<TNcdInterfaceId>(

        MNcdFileDownloadOperation::KInterfaceUid );

    }

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

CNcdFileDownloadOperationProxy::CNcdFileDownloadOperationProxy( 

    TNcdDownloadDataType aDataType )

    : CNcdOperation< MNcdFileDownloadOperation >( NULL ), iIsPaused( EFalse ),

       iDataType( aDataType )

    {

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CNcdFileDownloadOperationProxy::~CNcdFileDownloadOperationProxy()

    {

    DLTRACEIN( ( "" ) );    

    delete iTargetFilename; 

    DASSERT( iRemoveHandler ); 

    if ( iRemoveHandler )

        {        

        DLTRACE(("Removing proxy from remove handler"));

        iRemoveHandler->RemoveOperationProxy( *this );

        }

    DLTRACEOUT( ( "" ) );    

    }

// ---------------------------------------------------------------------------

// ConstructL

// ---------------------------------------------------------------------------

//

void CNcdFileDownloadOperationProxy::ConstructL( MCatalogsClientServer& aSession,

    TInt aHandle,

    MNcdOperationProxyRemoveHandler* aRemoveHandler,

    CNcdNodeProxy* aNode,

    CNcdNodeManagerProxy* aNodeManager,

    MNcdFileDownloadOperationObserver* aObserver,

    const TDesC& aTargetFilename )

    {

    DLTRACEIN( ( "" ) );

    CNcdBaseOperationProxy::ConstructL( aSession, aHandle, aRemoveHandler,

        aNode, aNodeManager );

    iObserver = aObserver;

    iTargetFilename = aTargetFilename.AllocL();

    // Initialize the operation if necessary. Initialization mechanism is used

    // here to transfer the targetfilename to serverside unless it is

    // transferred in node id    

    if ( aNode ) 

        {        

        InitializeOperationL();

        }

    DLTRACEOUT( ( "" ) );    

    }

// ---------------------------------------------------------------------------

// Handle progress callback

// ---------------------------------------------------------------------------

//

void CNcdFileDownloadOperationProxy::ProgressCallback()

    {

    DLTRACEIN( ( "" ) );

    if ( iObserver ) 

        {

        TNcdSendableProgress& sendableProgress( SendableProgress() );

        TNcdProgress progress( sendableProgress.iProgress, 

                               sendableProgress.iMaxProgress );

        iObserver->FileDownloadProgress( *this, progress );

        }

    DLTRACEOUT( ( "" ) );

    }

// ---------------------------------------------------------------------------

// Handle query received callback

// ---------------------------------------------------------------------------

//

void CNcdFileDownloadOperationProxy::QueryReceivedCallback( CNcdQuery* /*aQuery*/ )

    {

    DLTRACEIN( ( "" ) );

    DLTRACEOUT( ( "" ) );

    }

// ---------------------------------------------------------------------------

// Handle operation complete

// ---------------------------------------------------------------------------

//

void CNcdFileDownloadOperationProxy::CompleteCallback( TInt aError )

    {

    AddRef();

    DLTRACEIN( ( "Error: %d", aError ) );

    iIsPaused = EFalse;

    if ( iObserver ) 

        {        

        iObserver->OperationComplete( *this, aError );

        }

    Release();

    DLTRACEOUT( ( "" ) );

    }

// ---------------------------------------------------------------------------

// Create initialization data sent to the server-side

// ---------------------------------------------------------------------------

//

HBufC8* CNcdFileDownloadOperationProxy::CreateInitializationBufferL()

    {

    DLTRACEIN( ( "" ) );

    DASSERT( iTargetFilename );

    HBufC8* buf = HBufC8::NewLC( 2 * KMaxPath );

    TPtr8 ptr( buf->Des() );

    RDesWriteStream stream( ptr );

    CleanupClosePushL( stream );

    ExternalizeDesL( *iTargetFilename, stream );

    CleanupStack::PopAndDestroy( &stream );

    CleanupStack::Pop( buf );    

    return buf;

    }

// ---------------------------------------------------------------------------

// Handle initialization callback

// ---------------------------------------------------------------------------

//

void CNcdFileDownloadOperationProxy::InitializationCallback( 

    RReadStream& /* aReadStream */, TInt /* aDataLength */ )

    {

    DLTRACEIN( ( "" ) );

    }