diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/client/src/ncdproviderproxy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/client/src/ncdproviderproxy.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,1073 @@ +/* +* 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 CNcdProviderProxy::OperationsL() const + { + DLTRACEIN( ( "" ) ); + DASSERT( iOperationManager ); + + RCatalogsArray operations; + CleanupClosePushL( operations ); + + // Get the original array and insert its content to catalogs array. + // Also, increase the reference counter for the items. + const RPointerArray& 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 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 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, + &aObserver ); + + DLTRACEOUT(("")); + return dl; + } + + +// --------------------------------------------------------------------------- +// Default access point setter +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::SetDefaultConnectionMethodL( + const TNcdConnectionMethod& aAccessPointId ) + { + DLTRACEIN(( "aAccessPointId type=%u, id=%u", + aAccessPointId.iType, + aAccessPointId.iId )); + +#ifdef __SERIES60_31__ + if ( aAccessPointId.iType == ENcdConnectionMethodTypeDestination ) + { + DLERROR(("SNAPs are not supported in 3.1")); + User::Leave( KErrNotSupported ); + } +#endif + + TPtrC8 input( reinterpret_cast< const TUint8*>( &aAccessPointId ), + sizeof( aAccessPointId ) ); + TInt err; // note: not used? + + // Send the config + User::LeaveIfError( ClientServerSession().SendSync( + CNcdProvider::ENcdProviderSetDefaultAccessPoint, + input, + err, + Handle() ) ); + + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// Clears search results +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::ClearSearchResultsL() + { + iNodeManager->ClearSearchResultsL(); + } + + +// --------------------------------------------------------------------------- +// Clears client cache +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::ClearCacheL( TRequestStatus& aStatus ) + { + DLTRACEIN(("")); + + iOperationManager->CancelAllOperations(); + + // AsyncMediator is used to internalize favorites after cache cleanup + // because they may have changed due to database corruption + delete iAsyncMediator; + iAsyncMediator = NULL; + + iAsyncMediator = new( ELeave ) CCatalogsAsyncMediator( + aStatus, + TCallBack( &CNcdProviderProxy::InternalizeFavoriteManager, this ) ); + + // Notice that the proxy side node ram cache should be automatically cleared + // when the UI has released the nodes. + // This function is meant for the db cache clearing. + ClientServerSession().SendAsync( + CNcdProvider::ENcdProviderClearCache, + KNullDesC8, + iReturnBuf, + Handle(), + iAsyncMediator->iStatus ); + + iAsyncMediator->Activate(); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// Tells whether the SIM was changed since previous startup +// --------------------------------------------------------------------------- +// +TBool CNcdProviderProxy::IsSimChangedL() + { + DLTRACEIN(("")); + + TInt isChanged; + User::LeaveIfError( ClientServerSession().SendSync( + CNcdProvider::ENcdProviderIsSimChanged, + KNullDesC8, + isChanged, + Handle())); + + return isChanged; + } + + +// --------------------------------------------------------------------------- +// Tells whether engine uses fixed access point +// --------------------------------------------------------------------------- +// +TBool CNcdProviderProxy::IsFixedApL() + { + DLTRACEIN(("")); + + TInt isFixedAp; + User::LeaveIfError( ClientServerSession().SendSync( + CNcdProvider::ENcdProviderIsFixedAp, + KNullDesC8, + isFixedAp, + Handle() ) ); + + return isFixedAp; + } + + +// --------------------------------------------------------------------------- +// Downloads and installa a rights object +// --------------------------------------------------------------------------- +// +MNcdRightsObjectOperation* CNcdProviderProxy::DownloadAndInstallRightsObjectL( + MNcdRightsObjectOperationObserver& aObserver, + const TDesC& aDownloadUri, + const TDesC& aMimeType, + const TNcdConnectionMethod& aConnectionMethod ) + { + DLTRACEIN(( _L("aDownloadUri=%S, aMimeType=%S"), + &aDownloadUri, &aMimeType )); + DASSERT( iOperationManager ); + + CNcdRightsObjectOperationProxy* op = + iOperationManager->CreateRightsObjectOperationL( + aDownloadUri, aMimeType, aConnectionMethod, aObserver ); + + return op; + } + + +// --------------------------------------------------------------------------- +// Creates a new accesspoint +// --------------------------------------------------------------------------- +// +MNcdCreateAccessPointOperation* CNcdProviderProxy::CreateAccessPointL( + const TDesC& aAccessPointData, + MNcdCreateAccessPointOperationObserver& aObserver ) + { + DLTRACEIN(("")); + + CNcdCreateAccessPointOperationProxy* op = + iOperationManager->CreateCreateAccessPointOperationL( + aAccessPointData, + aObserver ); + + return op; + } + + +// --------------------------------------------------------------------------- +// Send a HTTP request +// --------------------------------------------------------------------------- +// +MNcdSendHttpRequestOperation* CNcdProviderProxy::SendHttpRequestL( + const TDesC8& aUri, + const TDesC8& aRequest, + const TNcdConnectionMethod& aConnectionMethod, + MNcdSendHttpRequestOperationObserver& aObserver ) + { + DLTRACEIN(("")); + CNcdSendHttpRequestOperationProxy* op = + iOperationManager->CreateSendHttpRequestOperationL( + aUri, + aRequest, + aConnectionMethod, + aObserver ); + return op; + + } + + +// --------------------------------------------------------------------------- +// Cliend ID getter +// --------------------------------------------------------------------------- +// +HBufC* CNcdProviderProxy::ClientIdL() + { + DLTRACEIN(("")); + + + RBuf clientId; + clientId.CleanupClosePushL(); + clientId.CreateL( NcdProviderDefines::KClientIdMaxLength ); + User::LeaveIfError( ClientServerSession().SendSync( + CNcdProvider::ENcdProviderClientId, + KNullDesC, + clientId, + Handle() ) ); + + HBufC* copy = clientId.AllocL(); + CleanupStack::PopAndDestroy( &clientId ); + return copy; + } + + +// --------------------------------------------------------------------------- +// Engine type getter +// --------------------------------------------------------------------------- +// +HBufC* CNcdProviderProxy::EngineTypeL() + { + return GetInfoFromProviderL( CNcdProvider::ENcdProviderInfoType ); + } + +// --------------------------------------------------------------------------- +// Engine version getter +// --------------------------------------------------------------------------- +// +HBufC* CNcdProviderProxy::EngineVersionL() + { + return GetInfoFromProviderL( CNcdProvider::ENcdProviderInfoVersion ); + } + + +// --------------------------------------------------------------------------- +// Engine provisioning getter +// --------------------------------------------------------------------------- +// +HBufC* CNcdProviderProxy::EngineProvisioningL() + { + return GetInfoFromProviderL( CNcdProvider::ENcdProviderInfoProvisioning ); + } + + +// --------------------------------------------------------------------------- +// Engine UID getter +// --------------------------------------------------------------------------- +// +HBufC* CNcdProviderProxy::EngineUidL() + { + return GetInfoFromProviderL( CNcdProvider::ENcdProviderInfoUid ); + } + + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +CNcdProviderProxy::CNcdProviderProxy( MCatalogsClientServer& aSession, + TInt aHandle ) +: CNcdInterfaceBaseProxy( aSession, aHandle, NULL ) + { + SetReleaseId( CNcdProvider::ENcdProviderRelease ); + } + + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::ConstructL() + { + DLTRACEIN(("")); + + // Register the interfaces + MNcdProvider* provider( this ); + AddInterfaceL( + CCatalogsInterfaceIdentifier::NewL( provider, this, + MNcdProvider::KInterfaceUid ) ); + + MNcdProviderPcClientSupport* support( this ); + AddInterfaceL( + CCatalogsInterfaceIdentifier::NewL( support, this, + MNcdProviderPcClientSupport::KInterfaceUid ) ); + + MNcdDebugInformation* debugInfo( this ); + AddInterfaceL( + CCatalogsInterfaceIdentifier::NewL( debugInfo, this, + MNcdDebugInformation::KInterfaceUid ) ); + + DLTRACE(("Base construct done")); + + // Create managers + // First operation manager because node manager uses it. + CreateOperationManagerL(); + + DLTRACE(("Operationmanager done")); + + CreateSubscriptionManagerL(); + + CreateNodeManagerL(); + + DLTRACE(("Nodemanager done")); + + iSubscriptionManager->SetNodeManager( iNodeManager ); + DLTRACE(("Subscriptionmanager done")); + + CreatePurchaseHistoryL(); + + DLTRACE(("Purchase history done")); + + CreateFavoriteManagerL(); + + iNodeManager->SetFavoriteManager( *iFavoriteManager ); + + CreateServerReportManagerL(); + + DLTRACE(("Favoritemanager done")); + + // This restores downloads from previous sessions + // NOTE: loads nodes and does other crazy stuff so keep it last + iOperationManager->RestoreContentDownloadsL(); + + } + + +// --------------------------------------------------------------------------- +// CreateNodeManagerL +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::CreateNodeManagerL() + { + DLTRACEIN(("")); + // Get the handle for the manager from the provider + TInt nodeManagerHandle( 0 ); + User::LeaveIfError( + ClientServerSession(). + SendSync( CNcdProvider::ENcdProviderNodeManagerHandle, + KNullDesC, + nodeManagerHandle, + Handle() ) ); + + // Use the same session for the manager as for the provider + iNodeManager = + CNcdNodeManagerProxy::NewL( ClientServerSession(), + nodeManagerHandle, + *iOperationManager, + *iSubscriptionManager, + *this ); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// CreatePurchaseHistoryL +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::CreatePurchaseHistoryL() + { + DLTRACEIN(("")); + // Get the handle for the manager from the provider + TInt purchaseHistoryHandle( 0 ); + User::LeaveIfError( + ClientServerSession().SendSync( + CNcdProvider::ENcdProviderPurchaseHistoryHandle, + KNullDesC, + purchaseHistoryHandle, + Handle() ) ); + + // Use the same session for the manager as for the provider + iPurchaseHistory = + CNcdPurchaseHistoryProxy::NewL( + ClientServerSession(), + purchaseHistoryHandle, + this, + *iOperationManager ); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// CreateOperationManagerL +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::CreateOperationManagerL() + { + + DLTRACEIN(("")); + + // Get the handle for the manager from the provider + TInt operationManagerHandle( 0 ); + + DLTRACE(("Before session")); + MCatalogsClientServer& session = ClientServerSession(); + DLTRACE(("After session: %X", &session)); + + User::LeaveIfError( + ClientServerSession(). + SendSync( CNcdProvider::ENcdProviderOperationManagerHandle, + KNullDesC, + operationManagerHandle, + Handle() ) ); + + DLTRACE(("Send done")); + + // Use the same session for the manager as for the provider + iOperationManager = + CNcdOperationManagerProxy::NewL( ClientServerSession(), + operationManagerHandle ); + DLTRACE(("Opmanager done")); + + } + +// --------------------------------------------------------------------------- +// CreateSubscriptionManagerL +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::CreateSubscriptionManagerL() + { + DLTRACEIN(("")); + // Get the handle for the manager from the provider + TInt subscriptionManagerHandle( 0 ); + User::LeaveIfError( + ClientServerSession(). + SendSync( + CNcdProvider::ENcdProviderSubscriptionManagerHandle, + KNullDesC, + subscriptionManagerHandle, + Handle() ) ); + + // Use the same session for the manager as for the provider + iSubscriptionManager = + CNcdSubscriptionManagerProxy::NewL( ClientServerSession(), + subscriptionManagerHandle, + this, + *iOperationManager ); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// CreateFavoriteManagerL +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::CreateFavoriteManagerL() + { + DLTRACEIN(("")); + // Get the handle for the manager from the provider + TInt favoriteManagerHandle( 0 ); + User::LeaveIfError( + ClientServerSession(). + SendSync( + CNcdProvider::ENcdProviderFavoriteManagerHandle, + KNullDesC, + favoriteManagerHandle, + Handle() ) ); + + // Use the same session for the manager as for the provider + iFavoriteManager = + CNcdFavoriteManagerProxy::NewL( ClientServerSession(), + favoriteManagerHandle, + this, + *iNodeManager ); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::CreateServerReportManagerL() + { + DLTRACEIN(("")); + // Get the handle for the manager from the provider + TInt managerHandle( 0 ); + User::LeaveIfError( + ClientServerSession(). + SendSync( + CNcdProvider::ENcdProviderServerReportManagerHandle, + KNullDesC, + managerHandle, + Handle() ) ); + + // Use the same session for the manager as for the provider + iServerReportManager = + CNcdServerReportManagerProxy::NewL( ClientServerSession(), + managerHandle, + *this ); + DLTRACEOUT(("")); + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +HBufC* CNcdProviderProxy::GetInfoFromProviderL( + TInt aInfoIndex ) + { + // Write aInfo to a descriptor + TBuf<1> info; + info.SetLength( 1 ); + info[0] = aInfoIndex; + + HBufC* 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. + User::LeaveIfError( + ClientServerSession(). + SendSyncAlloc( CNcdProvider::ENcdGetProviderInfo, + info, + data, + Handle(), + 0 ) ); + + if ( data == NULL ) + { + User::Leave( KErrNotFound ); + } + return data; + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CNcdProviderProxy::InternalizeFavoriteManagerL() + { + DLTRACEIN(("")); + iFavoriteManager->InternalizeL(); + } + + +// --------------------------------------------------------------------------- +// Given to TCallBack when clearing cache +// --------------------------------------------------------------------------- +// +TInt CNcdProviderProxy::InternalizeFavoriteManager( TAny* aProvider ) + { + DLTRACEIN(("")); + CNcdProviderProxy* provider = + static_cast( aProvider ); + DASSERT( provider ); + TRAPD( err, provider->InternalizeFavoriteManagerL() ); + return err; + }