/*

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

*

*/

#include "ncdoperationmanagerproxy.h"

#include <e32err.h>

#include "ncdbaseoperationproxy.h"

#include "ncdloadnodeoperationproxy.h"

#include "ncddownloadoperationproxy.h"

#include "ncdnodeproxy.h"

#include "ncdnodeidentifier.h"

#include "ncdloadnodeoperation.h"

#include "catalogsclientserver.h"

#include "ncdnodefunctionids.h"

#include "ncdfiledownloadoperationproxy.h"

#include "ncdpurchaseoperationproxy.h"

#include "catalogsconstants.h"

#include "catalogsutils.h"

#include "ncdpurchaseoptionproxy.h"

#include "ncdinstalloperationproxy.h"

#include "ncdsilentinstalloperationproxy.h"

#include "ncdrightsobjectoperationproxy.h"

#include "ncdsubscriptionoperationproxy.h"

#include "ncdnodemanagerproxy.h"

#include "ncddeviceinteractionfactory.h"

#include "ncdinstallationservice.h"

#include "ncdnodemetadataproxy.h"

#include "ncdcreateaccesspointoperationproxy.h"

#include "ncdsendhttprequestoperationproxy.h"

#include "ncdconnectionmethod.h"

#include "ncdserverreportoperationproxy.h"

#include "ncdproviderdefines.h"

#include "catalogsdebug.h"

CNcdOperationManagerProxy* CNcdOperationManagerProxy::NewL( MCatalogsClientServer& aSession, 

                                                            TInt aHandle )

    {

    CNcdOperationManagerProxy* self = CNcdOperationManagerProxy::NewLC( aSession, aHandle );

    CleanupStack::Pop( self );

    return self;

    }

CNcdOperationManagerProxy* CNcdOperationManagerProxy::NewLC( MCatalogsClientServer& aSession, 

                                                             TInt aHandle )

    {

    CNcdOperationManagerProxy* self = 

        new( ELeave ) CNcdOperationManagerProxy( aSession, aHandle );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;        

    }

CNcdOperationManagerProxy::~CNcdOperationManagerProxy()

    {

    DLTRACEIN((""));

    iRemovingAllOperations = ETrue;

    DLTRACE(("All operations should have been released by now"));

    DASSERT( iOperationCache.Count() == 0 );

    iOperationCache.Close();

    delete iInstallationService;

    DLTRACEOUT((""));

    }

void CNcdOperationManagerProxy::SetClientLocalizer(

    MNcdClientLocalizer& aLocalizer ) 

    {

    iClientLocalizer = &aLocalizer;

    }

CNcdLoadNodeOperationProxy* CNcdOperationManagerProxy::CreateLoadNodeOperationL( 

    CNcdNodeProxy& aNode, TBool aLoadChildren, TInt aPageSize, TInt aPageStart, TInt aDepth,

    TNcdChildLoadMode aMode, MNcdSearchFilter* aSearchFilter )

    {

    DLTRACEIN((""));

    CBufBase* buf = CBufFlat::NewL( KBufExpandSize );

    CleanupStack::PushL( buf );

    RBufWriteStream stream( *buf );

    CleanupClosePushL( stream );

    aNode.NodeIdentifier().ExternalizeL( stream );

    stream.WriteInt32L( aLoadChildren );

    stream.WriteInt32L( aPageSize );

    stream.WriteInt32L( aPageStart );

    stream.WriteInt32L( aDepth );

    stream.WriteInt32L( aMode );

    stream.WriteInt32L( aSearchFilter != NULL );

    if ( aSearchFilter )

        {        

        stream.WriteUint32L( aSearchFilter->ContentPurposes() );

        stream.WriteInt32L( aSearchFilter->Keywords().MdcaCount() );

        for ( TInt i = 0 ; i < aSearchFilter->Keywords().MdcaCount() ; i++ )

            {

            ExternalizeDesL( aSearchFilter->Keywords().MdcaPoint( i ), stream );

            }

        ExternalizeEnumL( aSearchFilter->SearchMode(), stream );

        stream.WriteUint32L( aSearchFilter->RecursionDepth() );        

        }    

    CleanupStack::PopAndDestroy( &stream );

    TPtrC8 ptr = buf->Ptr( 0 );    

    DLTRACE(("Create server side operation"));

    // Send message to server side operation manager to create the server side 

    // operation and to get a handle to the operation.

    TInt operationHandle( 0 );

    User::LeaveIfError(

            ClientServerSession().

                SendSync( NcdNodeFunctionIds::ENcdOperationManagerCreateLoadNodeOperation,

                          ptr,

                          operationHandle,

                          Handle() ) );

    CleanupStack::PopAndDestroy( buf );

    MNcdOperationProxyRemoveHandler* removeHandler( this );

    DLINFO(("operation handle: %d", operationHandle ));

    // Create operation proxy

    CNcdLoadNodeOperationProxy* operation = 

        CNcdLoadNodeOperationProxy::NewLC(

            ClientServerSession(), operationHandle, removeHandler, &aNode,

            iNodeManager, aSearchFilter != NULL, iClientLocalizer );

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );

    DLTRACEOUT((""));

    return operation;

    }

CNcdLoadNodeOperationProxy* CNcdOperationManagerProxy::CreateLoadRootNodeOperationL(

    CNcdNodeProxy& aNode )

    {

    DLTRACEIN((""));

    MNcdOperationProxyRemoveHandler* removeHandler( this );

    // Create operation on the server side

    TInt operationHandle = CreateOperationL( aNode, 

        NcdNodeFunctionIds::ENcdOperationManagerCreateLoadRootNodeOperation,

        removeHandler );

    // Create operation proxy

    CNcdLoadNodeOperationProxy* operation = 

        CNcdLoadNodeOperationProxy::NewLC(

            ClientServerSession(), operationHandle, removeHandler, &aNode,

                iNodeManager, EFalse, iClientLocalizer );

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );

    DLTRACEOUT((""));

    return operation;

    }

CNcdLoadNodeOperationProxy* CNcdOperationManagerProxy::CreateLoadBundleNodeOperationL(

    CNcdNodeProxy& aNode )

    {

    DLTRACEIN((""));

    MNcdOperationProxyRemoveHandler* removeHandler( this );

    // Create operation on the server side

    TInt operationHandle = CreateOperationL(

        aNode, NcdNodeFunctionIds::ENcdOperationManagerCreateLoadBundleNodeOperation,

        removeHandler );

    // Create operation proxy

    CNcdLoadNodeOperationProxy* operation =

        CNcdLoadNodeOperationProxy::NewLC(

            ClientServerSession(), operationHandle, removeHandler, &aNode,

            iNodeManager, EFalse, iClientLocalizer );

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );

    return operation;

    }

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

// Creates a new download operation

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

//

CNcdDownloadOperationProxy* CNcdOperationManagerProxy::CreateDownloadOperationL( 

    TNcdDownloadDataType aType, CNcdNodeProxy& aNode, const TDesC& /* aDataId */,

    MNcdDownloadOperationObserver* aObserver,

    TInt aDownloadIndex )

    {           

    DLTRACEIN((""));     

    MNcdOperationProxyRemoveHandler* removeHandler( this );

    // Use temporary node to create a download operation

    // http://jira.bothi.fi/jira/browse/PRECLI-1229

    // Ownership is not transferred

    CNcdNodeMetadataProxy* metadataProxy = aNode.Metadata();

    if ( !metadataProxy )

        {

        DLERROR(( "CNcdNodeMetadataProxy was NULL!" ));

        User::Leave( KErrNotFound );

        }

    CNcdNodeIdentifier& nodeIdentifier = metadataProxy->Identifier();

    CNcdNodeProxy* node = NULL;

    if( aType == ENcdContentDownload )

        {

        // Content download may be started from just purchase history data

        // even when chache is completely empty.

        // Always use temporary nodes in content downloads to prevent problems.

        node = &iNodeManager->CreateTemporaryOrSupplierNodeL(

                nodeIdentifier );

        }

    else

        {

        node = &aNode;

        }

    // Create the server side download

    TInt operationHandle = CreateServerSideDownloadOperationL( aType, 

        node->NodeIdentifier(), aDownloadIndex );

    // Check if the download already exists, increases refcount if operation

    // is found    

    CNcdDownloadOperationProxy* operation = FindExistingDownloadOperation(

        operationHandle );

    if ( operation ) 

        {

        DLTRACE(("Found existing download"));

        if ( aObserver ) 

            {                        

            operation->AddObserverL( *aObserver );

            }        

        return operation;

        }

    // Create operation proxy

    operation = CNcdDownloadOperationProxy::NewLC(

        ClientServerSession(), aType, operationHandle, removeHandler, node,

        aObserver, iNodeManager, aDownloadIndex );

    iOperationCache.AppendL( operation );    

    CleanupStack::Pop( operation );

    DLTRACEOUT((""));

    return operation;    

    }

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

// Creates a new file download operation

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

//

CNcdFileDownloadOperationProxy* CNcdOperationManagerProxy::CreateFileDownloadOperationL( 

    TNcdDownloadDataType aType, 

    CNcdNodeProxy& aNode, 

    MNcdFileDownloadOperationObserver* aObserver,

    const TDesC& aTargetPath )

    {

    DLTRACEIN((""));

    if ( !aTargetPath.Length() )

        {

        DLERROR(( "No target path, leaving with KErrArgument" ));

        User::Leave( KErrArgument );

        }

    MNcdOperationProxyRemoveHandler* removeHandler( this );    

    // Create the server side download

    TInt operationHandle = CreateServerSideDownloadOperationL( aType, 

        aNode.NodeIdentifier(), 0 );

    // Create operation proxy

    CNcdFileDownloadOperationProxy* operation = 

        CNcdFileDownloadOperationProxy::NewLC(

            ClientServerSession(), operationHandle, removeHandler, &aNode, 

            iNodeManager, aTargetPath, aObserver, aType );

    iOperationCache.AppendL( operation );    

    CleanupStack::Pop( operation );

    return operation;    

    }

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

// Creates a new file download operation

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

//

CNcdFileDownloadOperationProxy* 

    CNcdOperationManagerProxy::CreateFileDownloadOperationL( 

    TNcdDownloadDataType aType,

    const TDesC& aUri, 

    const TDesC& aTargetPath, 

    MNcdFileDownloadOperationObserver* aObserver )

    {

    DLTRACEIN((""));

    if ( !aUri.Length() || !aTargetPath.Length() )

        {

        DLERROR(( "No URI or target path, leaving with KErrArgument" ));

        User::Leave( KErrArgument );

        }

    MNcdOperationProxyRemoveHandler* removeHandler( this );    

    // Use node id for transferring URI and targetpath to server-side

    CNcdNodeIdentifier* id = CNcdNodeIdentifier::NewLC(

        aUri, aTargetPath, TUid::Null() );

    // Create the server side download

    TInt operationHandle = CreateServerSideDownloadOperationL( 

        ENcdGenericFileDownload, 

        *id,

        0 );

    CleanupStack::PopAndDestroy( id );

    // Create operation proxy

    CNcdFileDownloadOperationProxy* operation = 

        CNcdFileDownloadOperationProxy::NewLC(

            ClientServerSession(), operationHandle, removeHandler, NULL, 

            iNodeManager, aTargetPath, aObserver, aType );

    iOperationCache.AppendL( operation );    

    CleanupStack::Pop( operation );    

    DLTRACEOUT((""));

    return operation;

    }

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

// Creates a new purchase operation

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

//

CNcdPurchaseOperationProxy* CNcdOperationManagerProxy::CreatePurchaseOperationL( 

    CNcdNodeProxy& aNode, 

    CNcdPurchaseOptionProxy& aSelectedPurchaseOption,

    MNcdPurchaseOperationObserver* aObserver )

    {

    DLTRACEIN((""));

    MNcdOperationProxyRemoveHandler* removeHandler( this );    

    // Create operation on the server side

    TInt operationHandle = CreateServerSidePurchaseOperationL( 

        aNode, 

        aSelectedPurchaseOption, 

        NcdNodeFunctionIds::ENcdOperationManagerCreatePurchaseOperation,

        removeHandler );

    CNcdSubscriptionManagerProxy* subscriptionManager( NULL );

    if ( iNodeManager != NULL )

        {

        subscriptionManager = &iNodeManager->SubscriptionManager();

        }

    // Create operation proxy

    CNcdPurchaseOperationProxy* operation = 

        CNcdPurchaseOperationProxy::NewLC( 

            ClientServerSession(), 

            operationHandle, 

            removeHandler, 

            &aNode, 

            &aSelectedPurchaseOption,

            aObserver,

            subscriptionManager,

            iNodeManager,

            iClientLocalizer );

    iOperationCache.AppendL( operation );    

    CleanupStack::Pop( operation );

    return operation;    

    }

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

// Creates a new install operation

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

//         

CNcdInstallOperationProxy* CNcdOperationManagerProxy::CreateInstallOperationL(

    CNcdNodeProxy& aNode,

    MNcdInstallOperationObserver* aObserver )

    {

   DLTRACEIN((""));

    // Should get the actual object for this pointer!

    MNcdOperationProxyRemoveHandler* removeHandler( this );

    // Create operation on the server side

    TInt operationHandle = CreateOperationL( aNode, 

        NcdNodeFunctionIds::ENcdOperationManagerCreateInstallOperation,

        removeHandler );

    // Create operation proxy

    CNcdInstallOperationProxy* operation = 

        CNcdInstallOperationProxy::NewLC(

            ClientServerSession(), operationHandle, 

            removeHandler, &aNode, iNodeManager, aObserver,

            InstallationServiceL() );

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );

    DLTRACEOUT((""));

    return operation;    

    }

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

// Creates a new install operation

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

//         

CNcdSilentInstallOperationProxy* CNcdOperationManagerProxy::CreateSilentInstallOperationL(

    CNcdNodeProxy& aNode,

    MNcdInstallOperationObserver* aObserver,

    const SwiUI::TInstallOptions& aInstallOptions )

    {

   DLTRACEIN((""));

    // Should get the actual object for this pointer!

    MNcdOperationProxyRemoveHandler* removeHandler( this );

    // Create operation on the server side

    // Notice, that the installation is handled in the proxy side, and only some

    // basic functionality is in the server side.

    // Notice, that this leaves with KErrPermissionDenied if UI does not have enough

    // capabilites for silent install.

    TInt operationHandle = CreateOperationL( aNode, 

        NcdNodeFunctionIds::ENcdOperationManagerCreateSilentInstallOperation,

        removeHandler );

    // Create operation proxy

    CNcdSilentInstallOperationProxy* operation = 

        CNcdSilentInstallOperationProxy::NewLC(

            ClientServerSession(), operationHandle, 

            removeHandler, &aNode, iNodeManager, aObserver,

            InstallationServiceL(),

            aInstallOptions );

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );

    DLTRACEOUT((""));

    return operation;    

    }

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

// Creates a DRM rights object download & install operation

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

//

CNcdRightsObjectOperationProxy* 

    CNcdOperationManagerProxy::CreateRightsObjectOperationL(

    const TDesC& aDownloadUri, 

    const TDesC& aMimeType, 

    const TNcdConnectionMethod& aConnectionMethod,

    MNcdRightsObjectOperationObserver& aObserver )

    {

    DLTRACEIN((""));

    // Calculate size of input data buffer.

    TInt bufferLen = sizeof( TUint32 ) + aDownloadUri.Size() +  // URI length + text data

                     sizeof( TUint32 ) + aMimeType.Size() +     // mime type length + text data

                     sizeof( TNcdConnectionMethod );            // access point id

    // Allocate and build the input data buffer.

    CBufFlat* buffer = CBufFlat::NewL( bufferLen );

    CleanupStack::PushL( buffer );

    RBufWriteStream stream( *buffer );

    CleanupClosePushL( stream );

    ExternalizeDesL( aDownloadUri, stream );    // Don't use << (would convert to 8-bit)

    ExternalizeDesL( aMimeType, stream );

    aConnectionMethod.ExternalizeL( stream );

    // Send the command for creating the server side operation object.

    TInt operationHandle;  // communication handle to the created server side object

    User::LeaveIfError( ClientServerSession().SendSync(

        NcdNodeFunctionIds::ENcdOperationManagerCreateRightsObjectOperation,

        buffer->Ptr( 0 ),

        operationHandle,

        Handle() ) );

    DLINFO(( "Got server side operation object comm handle %d", operationHandle ));

    CleanupStack::PopAndDestroy( 2, buffer );   // stream-close, buffer

    // Create operation proxy

    CNcdRightsObjectOperationProxy* operation = 

        CNcdRightsObjectOperationProxy::NewLC(

            ClientServerSession(), iNodeManager, operationHandle, 

            *this, aObserver );

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );

    DLTRACEOUT((""));

    return operation;