/*

* Copyright (c) 2006-2008 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 CNcdProviderProxy class implementation

*

*/

#include "ncdproviderproxy.h"

#include "catalogsclientserver.h"

#include "ncdnodemanagerproxy.h"

#include "ncdpurchasehistoryproxy.h"

#include "ncdoperationmanagerproxy.h"

#include "ncdproviderimpl.h"

#include "ncdnodefolderproxy.h"

#include "ncdoperation.h"

#include "ncdnodeidentifier.h"

#include "catalogsdebug.h"

#include "ncdkeyvaluepair.h"

#include "ncdkeyvaluemap.h"

#include "catalogsutils.h"

#include "catalogsinterfaceidentifier.h"

#include "ncdrootnodeproxy.h"

#include "ncdutils.h"

#include "ncdfiledownloadoperationproxy.h"

#include "ncdsubscriptionmanagerproxy.h"

#include "ncdoperationdatatypes.h"

#include "ncdrightsobjectoperationproxy.h"

#include "ncdproviderdefines.h"

#include "ncdproviderobserver.h"

#include "ncdfavoritemanagerproxy.h"

#include "ncdschemenodetype.h"

#include "ncdpanics.h"

#include "catalogsasyncmediator.h"

#include "ncdcreateaccesspointoperationproxy.h"

#include "ncdsendhttprequestoperationproxy.h"

#include "ncdconnectionmethod.h"

#include "ncdserverreportmanagerproxy.h"

#include "catalogsconstants.h"

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

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

// NewL

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

//

CNcdProviderProxy* CNcdProviderProxy::NewL( MCatalogsClientServer& aSession, 

                                            TInt aHandle  )

    {

    CNcdProviderProxy* self =  

        CNcdProviderProxy::NewLC( aSession, aHandle );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CNcdProviderProxy* CNcdProviderProxy::NewLC( MCatalogsClientServer& aSession, 

                                             TInt aHandle  )

    {

    CNcdProviderProxy* self = 

        new( ELeave ) CNcdProviderProxy( aSession, aHandle );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CNcdProviderProxy::~CNcdProviderProxy()

    {

    DLTRACEIN((""));

    if ( iOperationManager ) 

        {

        // Release downloads that had been restored

        // from a previous session but not used by any clients.

        //

        // This has to be done before the Node manager is deleted because

        // operations can have references to nodes which have to be released

        // first

        iOperationManager->ReleaseUnusedOperations();

        }

    // 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( MNcdProvider::KInterfaceUid );

    DLTRACE(("Observers reset"));

    // Delete managers

    delete iServerReportManager;

    iServerReportManager = NULL;

    delete iNodeManager;

    iNodeManager = NULL;

    delete iPurchaseHistory;

    iPurchaseHistory = NULL;

    delete iOperationManager;

    iOperationManager = NULL;

    delete iSubscriptionManager;

    iSubscriptionManager = NULL;

    delete iFavoriteManager;

    iFavoriteManager = NULL;

    delete iAsyncMediator;

    iAsyncMediator = NULL;

    // Do not delete observers here.

    DLTRACEOUT(("Operation manager released"));

    }

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

// ExpirationCallback

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

//

void CNcdProviderProxy::ExpirationCallback( RCatalogsArray< MNcdNode >& aExpiredNodes )

    {

    DLTRACEIN((""));

    if( iObserver )

        {

        iObserver->ForceExpirationInformationReceived( aExpiredNodes );

        }

    }

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

// OperationManager 

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

//

CNcdOperationManagerProxy& CNcdProviderProxy::OperationManager()

    {

    return *iOperationManager;    

    }

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

// ServerReportManager

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

//

CNcdServerReportManagerProxy& CNcdProviderProxy::ServerReportManager()

    {

    return *iServerReportManager;

    }

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

// SetObserver 

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

//

void CNcdProviderProxy::SetObserver( MNcdProviderObserver* aObserver )

    {

    // No need to delete old observer. It is owned elsewhere.

    iObserver = aObserver;    

    }

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

// RootNodeL 

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

//

MNcdNode* CNcdProviderProxy::RootNodeL()

    {

    DLTRACEIN( ("") );

    DASSERT( iNodeManager );

    DLTRACE( ("Getting root node from the node manager") );

    // Node manager will handle the creation of the root.

    CNcdRootNodeProxy* root( &iNodeManager->RootNodeL() );

    DLTRACE(("Root: %X", root));

    // Increase also the reference counter by one here.

    // So, the root ref count is at least one when the user

    // gets it.

    root->AddRef();

    DLTRACEOUT((""));

    return root;    

    }

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

// OperationsL

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

//    

RCatalogsArray<MNcdOperation> CNcdProviderProxy::OperationsL() const

    {

    DLTRACEIN( ( "" ) );

    DASSERT( iOperationManager );

    RCatalogsArray<MNcdOperation> operations;

    CleanupClosePushL( operations );

    // Get the original array and insert its content to catalogs array.

    // Also, increase the reference counter for the items.

    const RPointerArray<MNcdOperation>& origArray = iOperationManager->Operations();

    MNcdOperation* oper( NULL );

    operations.ReserveL( origArray.Count() );

    for ( TInt i = 0; i < origArray.Count(); ++i )

        {

        oper = origArray[ i ];

        operations.AppendL( oper );

        oper->AddRef();

        }

    DLTRACEOUT( ( "" ) );

    CleanupStack::Pop( &operations );

    return operations;

    }

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

// PurchaseHistoryL 

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

//    

MNcdPurchaseHistory* CNcdProviderProxy::PurchaseHistoryL() const

    {

    DLTRACEIN( ("") );

    DASSERT( iPurchaseHistory );

    DLTRACE( ("Getting purchase history") );

    // Get purchase history interface.

    MNcdPurchaseHistory* history( iPurchaseHistory );

    // Increase also the reference counter by one here.

    history->AddRef();

    DLTRACEOUT( ("Purchase history: %X", history ) );

    return history;    

    }

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

// SubscriptionsL

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

//    

MNcdSubscriptionManager* CNcdProviderProxy::SubscriptionsL() const

    {

    DLTRACEIN( ( "" ) );

    DASSERT( iSubscriptionManager );

    iSubscriptionManager->AddRef();        

    return iSubscriptionManager;

    }

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

// AddConfigurationL 

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

//    

void CNcdProviderProxy::AddConfigurationL( const MNcdKeyValuePair& aConfiguration )

    {

    DLTRACEIN(( _L("Key: %S, value: %S"), &aConfiguration.Key(),

        &aConfiguration.Value() ));

    // Externalize the config.

    CNcdKeyValuePair* config = CNcdKeyValuePair::NewLC( aConfiguration );

    HBufC8* data = config->ExternalizeToDesLC();

    TBuf8<1> err;

    // Send the config

    User::LeaveIfError( ClientServerSession().SendSync( 

        CNcdProvider::ENcdProviderAddConfiguration,

        *data,

        err,

        Handle() ) );

    CleanupStack::PopAndDestroy( data );

    CleanupStack::PopAndDestroy( config );

    DLTRACEOUT((""));

    }

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

// RemoveConfigurationL 

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

//    

void CNcdProviderProxy::RemoveConfigurationL( const TDesC& aKey )

    {

    DLTRACEIN(( _L("Key: %S"), &aKey ) );

    RCatalogsBufferWriter source;

    source.OpenLC();

    ExternalizeDesL( aKey, source() );

    TBuf8<1> buf;

    // Send the config

    User::LeaveIfError(

            ClientServerSession().

                SendSync( CNcdProvider::ENcdProviderRemoveConfiguration,

                          source.PtrL(),

                          buf,

                          Handle() ) );

    CleanupStack::PopAndDestroy( &source );

    TInt err = buf[0];

    DLTRACEOUT( ( "Provider returned err: %d", err ) );

    User::LeaveIfError( err );

    }

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

// ConfigurationsL

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

//    

RPointerArray<CNcdKeyValuePair> CNcdProviderProxy::ConfigurationsL() const

    {

    DLTRACEIN( ( "" ) );        

    HBufC8* buf = NULL;

    // Ask for the configs

    User::LeaveIfError(

            ClientServerSession().

                SendSyncAlloc( CNcdProvider::ENcdProviderRetrieveConfigurations,

                          KNullDesC8,

                          buf,

                          Handle(),

                          0 ) );

    User::LeaveIfNull( buf );

    DLINFO(("Received %d bytes", buf->Length() ));

    CleanupStack::PushL( buf );

    RDesReadStream stream( *buf );

    CleanupClosePushL( stream );

    CNcdKeyValueMap* map = CNcdKeyValueMap::NewLC();

    map->InternalizeL( stream );

    // Copy the pointers. RPointerArray's copy constructor doesn't 

    // work correctly

    RPointerArray<CNcdKeyValuePair> pairs;    

    pairs.ReserveL( map->Pairs().Count() );

    for ( TInt i = 0; i < map->Pairs().Count(); ++i ) 

        {

        pairs.Append( map->Pairs()[i] );

        }

    // Reset the map so that the actual pairs are not deleted with

    // the map    

    map->Reset();    

    CleanupStack::PopAndDestroy( 3 ); // map, stream, buf

    DLTRACEOUT(("Config count: %d", pairs.Count() ));

    return pairs;

    }

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

// NodeL

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

//    

MNcdNode* CNcdProviderProxy::NodeL( const TDesC& aNameSpaceId, 

                                    const TDesC& aNodeId ) const

    {

    DLTRACEIN( ( "namespace: %S, id: %S", &aNameSpaceId, &aNodeId ) );

    DASSERT( iNodeManager );

    DLTRACE( ( "Getting node from the node manager" ) );

    // NOTE!!! That the identifier is set here NULL! This is because

    // we do not know the actual UID here. But this uid value will be

    // replaced by the correct value when the server actually creates the

    // node.

    // NOTE ALSO!!! The server uri has not been set here for the node. So,

    // the server side should not use the uri when comparing nodes in this case.

    CNcdNodeIdentifier* identifier( 

        CNcdNodeIdentifier::NewLC( aNameSpaceId, aNodeId, TUid::Null() ) );

    // Node manager will handle the creation of the root.

    MNcdNode* node( &iNodeManager->NodeL( *identifier ) );

    CleanupStack::PopAndDestroy( identifier );

    // Increase also the reference counter by one here.

    // So, the root ref count is at least one when the user

    // gets it.

    DASSERT( node );

    node->AddRef();

    DLTRACEOUT( ( "" ) );

    return node;    

    }

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

// NodeL

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

//        

MNcdNode* CNcdProviderProxy::NodeL( const MNcdPurchaseDetails& aDetails ) const

    {

    DLTRACEIN((""));

    // This function call will create the temporary node according to the

    // purchase details. Even if the node and its metadata does not exist

    // in the RAM cache or in the db, the server will create a metadata and

    // a temporary node according to the info gotten from the purchase details.

    MNcdNode* node( &iNodeManager->CreateTemporaryNodeL( aDetails ) );

    // Increase also the reference counter by one here.

    // So, the root ref count is at least one when the user

    // gets it.

    DASSERT( node );

    node->AddRef();

    DLTRACEOUT((""));

    return node;

    }

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

// SchemeNodeL

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

//    

MNcdNode* CNcdProviderProxy::SchemeNodeL( const TDesC& aNameSpaceId, 

                                          const TDesC& aEntityId,

                                          const TDesC& aServerUri,

                                          TNcdSchemeNodeType aType,

                                          TBool aRemoveOnDisconnect,

                                          TBool aForceCreate ) const

    {

    DLTRACEIN((_L("namespace: %S, id: %S"), &aNameSpaceId, &aEntityId));

    DASSERT( iNodeManager );

    DLTRACE( ( "Getting node from the node manager" ) );

    // NOTE!!! That the identifier is set here NULL! This is because

    // we do not know the actual UID here. But this uid value will be

    // replaced by the correct value when the server actually creates the

    // node.

    CNcdNodeIdentifier* identifier( 

        CNcdNodeIdentifier::NewLC(

            aNameSpaceId,

            aEntityId,

            aServerUri,

            TUid::Null() ) );

    if ( identifier->ContainsEmptyFields( ETrue, ETrue, ETrue, EFalse ) ) 

        {

        DLINFO(("Empty identifier fields, leave KErrArgument"));

        User::Leave( KErrArgument );

        }

    // Node manager will handle the creation of the scheme node.

    MNcdNode* node( NULL );

    node = &iNodeManager->CreateSchemeNodeL(

            *identifier, aType, aRemoveOnDisconnect, aForceCreate );

    CleanupStack::PopAndDestroy( identifier );

    // Increase also the reference counter by one here.

    // So, the root ref count is at least one when the user

    // gets it.

    DASSERT( node );

    node->AddRef();

    DLINFO(("node state: %d", node->State() ));                

    DLTRACEOUT((""));    

    return node;    

    }

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

// SetStringLocalizer

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

//

void CNcdProviderProxy::SetStringLocalizer( MNcdClientLocalizer& aLocalizer )

    {

    iClientLocalizer = &aLocalizer;

    iOperationManager->SetClientLocalizer( aLocalizer );

    }

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

// File download creator

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

//

MNcdFileDownloadOperation* CNcdProviderProxy::DownloadFileL( const TDesC& aUri,

    const TDesC& aTargetFileName,

    MNcdFileDownloadOperationObserver& aObserver )

    {

    DLTRACEIN((""));

    DASSERT( iOperationManager );

    MNcdFileDownloadOperation* dl = 

        iOperationManager->CreateFileDownloadOperationL(

            ENcdGenericFileDownload,

            aUri, 

            aTargetFileName,