diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/client/src/ncdnodemetadataproxy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/client/src/ncdnodemetadataproxy.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,1562 @@ +/* +* 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 CNcdNodeMetadataProxy class implementation +* +*/ + + +#include "ncdnodemetadataproxy.h" +#include "ncdnodeproxy.h" +#include "ncdnodemanagerproxy.h" +#include "ncdnodedisclaimerproxy.h" +#include "ncdnodedownloadproxy.h" +#include "ncdnodeiconproxy.h" +#include "ncdnodescreenshotproxy.h" +#include "ncdnodepurchaseproxy.h" +#include "ncdnodeuricontentproxy.h" +#include "ncdnodecontentinfoproxy.h" +#include "ncdnodeinstallproxy.h" +#include "ncdnodeactivateimpl.h" +#include "ncdnodepreviewproxy.h" +#include "ncdnodeupgradeproxy.h" +#include "ncdnodedependencyproxy.h" +#include "ncdnodeskinproxy.h" +#include "catalogsclientserver.h" +#include "ncdnodeidentifier.h" +#include "ncdnodefunctionids.h" +#include "ncdnodeclassids.h" +#include "ncdnodeuserdataproxy.h" +#include "catalogsinterfaceidentifier.h" +#include "catalogsdebug.h" +#include "catalogsutils.h" +#include "ncdutils.h" +#include "ncderrors.h" + + +// ======== PUBLIC MEMBER FUNCTIONS ======== + +CNcdNodeMetadataProxy::CNcdNodeMetadataProxy( MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeProxy& aNode ) +: CNcdInterfaceBaseProxy( aSession, aHandle, &aNode ), + iNode( aNode ) + { + } + + +void CNcdNodeMetadataProxy::ConstructL() + { + // Register the interface + MNcdNodeMetadata* metadata( this ); + DLTRACE(("Metadata-ptr: %X, this: %X", metadata, this)); + AddInterfaceL( + CCatalogsInterfaceIdentifier::NewL( metadata, this, MNcdNodeMetadata::KInterfaceUid ) ); + + InternalizeL(); + } + + +CNcdNodeMetadataProxy* CNcdNodeMetadataProxy::NewL( MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeProxy& aNode ) + { + CNcdNodeMetadataProxy* self = + CNcdNodeMetadataProxy::NewLC( aSession, aHandle, aNode ); + CleanupStack::Pop( self ); + return self; + } + +CNcdNodeMetadataProxy* CNcdNodeMetadataProxy::NewLC( MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeProxy& aNode ) + { + CNcdNodeMetadataProxy* self = + new( ELeave ) CNcdNodeMetadataProxy( aSession, aHandle, aNode ); + // Using PushL because the object does not have any references yet + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + +CNcdNodeMetadataProxy::~CNcdNodeMetadataProxy() + { + DLTRACEIN(("Metadata: %X", this)); + // 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( MNcdNodeMetadata::KInterfaceUid ); + + // Do not delete parent node. It is just a reference to the parent and the + // parent owns this metadata, not vice versa. + + delete iIdentifier; + iIdentifier = NULL; + + delete iName; + iName = NULL; + + delete iDescription; + iDescription = NULL; + + delete iLayoutType; + iLayoutType = NULL; + + delete iActionName; + iActionName = NULL; + + + // Delete the objects that are owned by this class and provide functionality + // through the api. + // Notice that the api-objects are Released (not deleted) from the UI side. + // This object owns the data and the reference counter of this object keeps + // track of the api objects it owns. When the reference counter of this object + // reaches zero, it means that nobody is using this object or the classes owned + // by this object. If somebody is using the object owned by this object, + // the reference counter can not be zero until everything is released. + // Thus, this object may delete the data here. + + delete iDisclaimer; + iDisclaimer = NULL; + + DLTRACE(("Deleting iMoreInfo")); + delete iMoreInfo; + iMoreInfo = NULL; + + DLTRACE(("Deleting iUserData")); + delete iUserData; + iUserData = NULL; + + DLTRACE(("Deleting iDownload")); + delete iDownload; + iDownload = NULL; + + DLTRACE(("Deleting iIcon")); + delete iIcon; + iIcon = NULL; + + DLTRACE(("Deleting iScreenshot")); + delete iScreenshot; + iScreenshot = NULL; + + DLTRACE(("Deleting iPurchase")); + delete iPurchase; + iPurchase = NULL; + + DLTRACE(("Deleting iUriContent")); + delete iUriContent; + iUriContent = NULL; + + DLTRACE(("Deleting iContentInfo")); + delete iContentInfo; + iContentInfo = NULL; + + DLTRACE(("Delete install")); + delete iInstall; + iInstall = NULL; + + DLTRACE(("Deleting iPreview")); + delete iPreview; + iPreview = NULL; + + DLTRACE(("Deleting iUpgrade")); + delete iUpgrade; + iUpgrade = NULL; + + DLTRACE(("Deleting iDependency")); + delete iDependency; + iDependency = NULL; + + DLTRACE(("Deleting iSkin")); + delete iSkin; + iSkin = NULL; + + DLTRACE(("Deleting iActivate")); + delete iActivate; + iActivate = NULL; + + DLTRACE(("Deleting iDetails")); + iDetails.ResetAndDestroy(); + DLTRACEOUT(( "Metadata deleted, this: %x", this )); + } + +CNcdNodeIdentifier& CNcdNodeMetadataProxy::Identifier() const + { + return *iIdentifier; + } + +CNcdNodeProxy& CNcdNodeMetadataProxy::Node() const + { + return iNode; + } + +CNcdNodeDownloadProxy* CNcdNodeMetadataProxy::Download() const + { + return iDownload; + } + + +CNcdNodeInstallProxy* CNcdNodeMetadataProxy::Install() const + { + return iInstall; + } + + +CNcdNodeUriContentProxy* CNcdNodeMetadataProxy::UriContent() const + { + return iUriContent; + } + + +CNcdNodeContentInfoProxy* CNcdNodeMetadataProxy::ContentInfo() const + { + return iContentInfo; + } + + +void CNcdNodeMetadataProxy::InternalizeL() + { + DLTRACEIN(("Metadata: %X", this)); + + HBufC8* data( NULL ); + + // Because we do not know the exact size of the data id, 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( NcdNodeFunctionIds::ENcdInternalize, + KNullDesC8, + data, + Handle(), + 0 ) ); + + if ( data == NULL ) + { + 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 ); + + // These functions internalize objects that may exist + // in the server side metadata. + + // The node should always contain user data object. + DLINFO(("Internalize user data")); + TRAP_IGNORE( InternalizeUserDataL() ); + + DLINFO(("Internalize icon")); + TRAP_IGNORE( InternalizeIconL() ); + + DLINFO(("Internalize content info")); + TRAP_IGNORE( InternalizeContentInfoL() ); + + DLINFO(("Internalize upgrade target info")); + TRAP_IGNORE( InternalizeUpgradeL() ); + + DLINFO(("Internalize dependency target info")); + TRAP_IGNORE( InternalizeDependencyL() ); + + DLINFO(("Internalize preview")); + TRAP_IGNORE( InternalizePreviewL() ); + + DLINFO(("Internalize node purchase")); + TRAP_IGNORE( InternalizePurchaseL() ); + + DLINFO(("Internalize uri content")); + TRAP_IGNORE( InternalizeUriContentL() ); + + DLINFO(("Internalize download")); + TRAP_IGNORE( InternalizeDownloadL() ); + + DLINFO(("Internalize install")); + TRAP_IGNORE( InternalizeInstallL() ); + + DLINFO(("Internalize skin")); + TRAP_IGNORE( InternalizeSkinL() ); + + // Activate can exist only after install info has been gotten. + DLINFO(("Internalize activate")); + TRAP_IGNORE( InternalizeActivateL() ); + + DLINFO(("Internalize screenshot")); + TRAPD( err, InternalizeScreenshotL() ); + + // Ignore errors caused by obsolete screenshot + LeaveIfNotErrorL( err, KNcdErrorObsolete ); + + DLTRACEOUT(("")); + } + + +// MNcdNodeMetaData functions + +const TDesC& CNcdNodeMetadataProxy::Id() const + { + return iIdentifier->NodeId(); + } + +const TDesC& CNcdNodeMetadataProxy::Namespace() const + { + return iIdentifier->NodeNameSpace(); + } + + +const TDesC& CNcdNodeMetadataProxy::Name() const + { + DLTRACEIN(("Metadata: %X", this)); + DASSERT( iName ); + DLINFO(( _L("Name: %S, length: %d"), iName, + iName->Length() )); + return *iName; + } + + +const TDesC& CNcdNodeMetadataProxy::Description() const + { + DLTRACEIN(("Metadata: %X", this)); + DASSERT( iDescription ); + DLINFO(( _L("Description: %S, length: %d"), iDescription, + iDescription->Length() )); + return *iDescription; + } + +MNcdQuery* CNcdNodeMetadataProxy::Disclaimer() const + { + DLTRACEIN(("TotalRefCount: %d", TotalRefCount())); + if( iDisclaimer != NULL ) + { + iDisclaimer->AddRef(); + } + + DLTRACEOUT(("")); + return iDisclaimer; + } + +MNcdQuery* CNcdNodeMetadataProxy::MoreInfo() const + { + DLTRACEIN(("TotalRefCount: %d", TotalRefCount())); + if( iMoreInfo != NULL ) + { + iMoreInfo->AddRef(); + } + + DLTRACEOUT(("")); + return iMoreInfo; + } + +const RPointerArray& + CNcdNodeMetadataProxy::Details() const + { + DLTRACEIN(("")); + return iDetails; + } + +const TDesC& CNcdNodeMetadataProxy::ActionName() const + { + return *iActionName; + } + + +TBool CNcdNodeMetadataProxy::IsAlwaysVisible() const + { + DLTRACEIN((("isAlwaysVisible: %d"), iIsAlwaysVisible )) + return iIsAlwaysVisible; + } + +const TDesC& CNcdNodeMetadataProxy::LayoutType() const + { + return *iLayoutType; + } + + +void CNcdNodeMetadataProxy::InternalizeDataL( RReadStream& aStream ) + { + DLTRACEIN(("Metadata: %X", this)); + + CNcdNodeIdentifier* tmpIdentifier( NULL ); + HBufC* tmpName( NULL ); + HBufC* tmpDescription( NULL ); + HBufC* tmpActionName( NULL ); + HBufC* tmpLayoutType( NULL ); + TBool tmpAlwaysVisible( EFalse ); + RPointerArray details; + CleanupResetAndDestroyPushL( details ); + + // Get the id for the metadata class + TInt classId = aStream.ReadInt32L(); + + if( classId != NcdNodeClassIds::ENcdNullObjectClassId ) + { + DLINFO(("Metadata exists")); + + tmpIdentifier = CNcdNodeIdentifier::NewLC( aStream ); + + InternalizeDesL( tmpName, aStream ); + CleanupStack::PushL( tmpName ); + + InternalizeDesL( tmpDescription, aStream ); + CleanupStack::PushL( tmpDescription ); + + InternalizeDesL( tmpLayoutType, aStream ); + CleanupStack::PushL( tmpLayoutType ); + + tmpAlwaysVisible = aStream.ReadInt8L(); + + TInt32 detailCount = aStream.ReadInt32L(); + for( TInt i = 0 ; i < detailCount ; i++ ) + { + CNcdKeyValuePair* detail = CNcdKeyValuePair::NewLC( aStream ); + DLTRACE(( _L("Detail id=%S, value=%S"), + &detail->Key() , &detail->Value() )); + details.AppendL( detail ); + CleanupStack::Pop( detail ); + } + + // What is this? + tmpActionName = KNullDesC().AllocLC(); + + InternalizeDisclaimerL(); + InternalizeMoreInfoL(); + } + else + { + DLINFO(("No meta data")); + + // Metadata has been created. But, during the internalization we found that it + // does not actually exist in the server side. Maybe it has been removed. + // Thus, leave here with KErrNotFound. So, metadata can be removed by the owner. + User::Leave( KErrNotFound ); + } + + // Finally it is safe to insert data to the member variables + + delete iActionName; + iActionName = tmpActionName; + CleanupStack::Pop( tmpActionName ); + + delete iLayoutType; + iLayoutType = tmpLayoutType; + CleanupStack::Pop( tmpLayoutType ); + + delete iDescription; + iDescription = tmpDescription; + CleanupStack::Pop( tmpDescription ); + + delete iName; + iName = tmpName; + CleanupStack::Pop( tmpName ); + + delete iIdentifier; + iIdentifier = tmpIdentifier; + CleanupStack::Pop( tmpIdentifier ); + + iIsAlwaysVisible = tmpAlwaysVisible; + + CleanupStack::Pop( &details ); + iDetails.ResetAndDestroy(); + + // Ownership of the array items is "transferred" to iDetails. + iDetails = details; + + DLTRACEOUT(("")); + } + + +void CNcdNodeMetadataProxy::InternalizeUserDataL() + { + DLTRACEIN(("")); + + // Get the handle for the link data + if ( iUserData == NULL ) + { + DLINFO(("User data was not set. Set it now.")); + TInt userDataHandle( 0 ); + + User::LeaveIfError( + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdUserDataHandle, + KNullDesC, + userDataHandle, + Handle() ) ); + DLINFO(("Handle: %i", userDataHandle)); + + // Now we can create the user data object + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iUserData = CNcdNodeUserDataProxy::NewL( ClientServerSession(), + userDataHandle, + *this ); + // Userdata ref counter is not increased here. + // So, it will be zero until somebody asks for the userdata. + // If the Release is called and + // when the reference counter reaches zero, this node which + // acts as parent will be deleted. The destructor of this + // node will delete the userdata because this node owns it. + } + + // Nothing else to do here, because user data will does not need + // any other internalizing. + + DLTRACEOUT(("")); + } + + +void CNcdNodeMetadataProxy::InternalizeDisclaimerL() + { + DLTRACEIN(("")); + + // Also update disclaimer information + if ( iDisclaimer == NULL ) + { + // Because disclaimer does not exist. It has to be created. + // Get the handle from the server side metadata + + // Check if the metadata exists in the server side and update the information + TInt disclaimerHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdDisclaimerHandle, + KNullDesC, + disclaimerHandle, + Handle() ); + + + if ( handleError == KErrNotFound ) + { + DLINFO(("Disclaimer did not exist in server side")); + + // Because disclaimer did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Disclaimer existed")); + + // Now we can create the disclaimer object + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + iDisclaimer = CNcdNodeDisclaimerProxy::NewL( ClientServerSession(), + disclaimerHandle, + this ); + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iDisclaimer->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("Disclaimer was obsolete")); + if ( iDisclaimer->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iDisclaimer; + } + + // Set disclaimer NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iDisclaimer = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + + DLTRACEOUT(("")); + } + +void CNcdNodeMetadataProxy::InternalizeMoreInfoL() + { + DLTRACEIN(("")); + + if ( iMoreInfo == NULL ) + { + // Because more info does not exist. It has to be created. + // Get the handle from the server side metadata + + // Check if the metadata exists in the server side and update the information + TInt moreInfoHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdMoreInfoHandle, + KNullDesC, + moreInfoHandle, + Handle() ); + + + if ( handleError == KErrNotFound ) + { + DLINFO(("More info did not exist in server side")); + + // Because more info did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("More info existed")); + + // Now we can create the disclaimer object + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + iMoreInfo = CNcdNodeDisclaimerProxy::NewL( ClientServerSession(), + moreInfoHandle, + this ); + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iMoreInfo->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("More info was obsolete")); + if ( iMoreInfo->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iMoreInfo; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iMoreInfo = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + + DLTRACEOUT(("")); + } + +void CNcdNodeMetadataProxy::InternalizeDownloadL() + { + DLTRACEIN(("this-ptr: %x", this)); + + if ( iDownload == NULL ) + { + DLINFO(("Download did not exist")); + + // Check if the download exists in the server side and update the information + TInt downloadHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdDownloadHandle, + KNullDesC, + downloadHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Download did not exist in server side")); + + // Because download did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Download existed")); + + // Now we can create the download object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iDownload = CNcdNodeDownloadProxy::NewL( ClientServerSession(), + downloadHandle, + *this ); + // Download ref counter is not increased here. + // So, it will be zero until somebody asks for the download. + // If the Release is called and + // when the reference counter reaches zero, this object which + // acts as parent will be deleted. The destructor of this + // object will delete the download because this node owns it. + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + iDownload->InternalizeL(); + } + + DLTRACEOUT(("")); + } + + +void CNcdNodeMetadataProxy::InternalizeUpgradeL() + { + DLTRACEIN(("")); + + if ( iUpgrade == NULL ) + { + DLINFO(("Upgrade info did not exist")); + + // The upgrade info info is part of the metadata. + // Update the information if it exists. + TInt upgradeHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdUpgradeHandle, + KNullDesC, + upgradeHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Upgrade info did not exist in server side")); + + // Because upgrade did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Upgrade info existed in the server side")); + + // Now we can create the upgrade info object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iUpgrade = CNcdNodeUpgradeProxy::NewL( ClientServerSession(), + upgradeHandle, + *this ); + // Upgrade ref counter is not increased here. + // So, it will be zero until somebody asks for the upgrade info. + // If the Release is called and + // when the reference counter reaches zero, this object which + // acts as parent will be deleted. The destructor of this + // object will delete the upgrade info because this node owns it. + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iUpgrade->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("Upgrade was obsolete")); + if ( iUpgrade->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iUpgrade; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iUpgrade = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + DLTRACEOUT(("")); + } + + +void CNcdNodeMetadataProxy::InternalizeDependencyL() + { + DLTRACEIN(("")); + + if ( iDependency == NULL ) + { + DLINFO(("Dependency info did not exist")); + + // The dependency info info is part of the metadata. + // Update the information if it exists. + TInt dependencyHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdDependencyHandle, + KNullDesC, + dependencyHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Dependency info did not exist in server side")); + + // Because dependency did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Dependency info existed in the server side")); + + // Now we can create the dependency info object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iDependency = CNcdNodeDependencyProxy::NewL( ClientServerSession(), + dependencyHandle, + *this ); + // Dependency ref counter is not increased here. + // So, it will be zero until somebody asks for the dependency info. + // If the Release is called and + // when the reference counter reaches zero, this object which + // acts as parent will be deleted. The destructor of this + // object will delete the dependency info because this node owns it. + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iDependency->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("Dependency was obsolete")); + if ( iDependency->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iDependency; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iDependency = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + DLTRACEOUT(("")); + } + + +void CNcdNodeMetadataProxy::InternalizeIconL() + { + DLTRACEIN(("")); + + if ( iIcon == NULL ) + { + DLINFO(("Icon did not exist")); + + // The icon info is part of the metadata. + // Update the information if it exists. + TInt iconHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdIconHandle, + KNullDesC, + iconHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Icon did not exist in server side")); + + // Because icon did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Icon existed in the server side")); + + // Now we can create the icon object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iIcon = CNcdNodeIconProxy::NewL( ClientServerSession(), + iconHandle, + *this ); + // Icon ref counter is not increased here. + // So, it will be zero until somebody asks for the icon. + // If the Release is called and + // when the reference counter reaches zero, this object which + // acts as parent will be deleted. The destructor of this + // object will delete the icon because this object owns it. + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iIcon->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("Icon was obsolete")); + if ( iIcon->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iIcon; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iIcon = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + DLTRACEOUT(("")); + } + +void CNcdNodeMetadataProxy::InternalizeScreenshotL() + { + DLTRACEIN(("")); + + if ( iScreenshot == NULL ) + { + DLINFO(("Screenshot did not exist")); + + // Check if the metadata exists in the server side. + // The screenshot info is part of the metadata. + // Update the information if it exists. + TInt screenshotHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdScreenshotHandle, + KNullDesC, + screenshotHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Screenshot did not exist in server side")); + + // Because screenshot did not exist in the server side. + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Screenshot existed in the server side")); + + // Now we can create the screenshot object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iScreenshot = + CNcdNodeScreenshotProxy::NewL( ClientServerSession(), + screenshotHandle, + *this ); + // Screenshot ref counter is not increased here. + // So, it will be zero until somebody asks for the screenshot. + // If the Release is called and + // when the reference counter reaches zero, this object which + // acts as parent will be deleted. The destructor of this + // object will delete the screenshot because this node owns it. + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iScreenshot->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("Screenshot was obsolete")); + if ( iScreenshot->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iScreenshot; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iScreenshot = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + DLTRACEOUT(("")); + } + +void CNcdNodeMetadataProxy::InternalizePurchaseL() + { + DLTRACEIN(("")); + + TBool isPurchaseSupported = EFalse; + // First check if this node should have purchase interface + User::LeaveIfError( + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdIsPurchaseSupported, + KNullDesC, + isPurchaseSupported, + Handle() ) ); + + if ( isPurchaseSupported && iPurchase == NULL ) + { + DLINFO(("Purchase is supported -> create.")); + + // Check if the metadata exists in the server side and update the information + TInt metadataHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdMetadataHandle, + KNullDesC, + metadataHandle, + Node().Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Metadata did not exist in server side")); + + // Because metadata did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + // Now we can create the purchase object. + // Notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iPurchase = CNcdNodePurchaseProxy::NewL( + ClientServerSession(), + metadataHandle, + *this ); + // Purchase ref counter is not increased here. + // And when someone asks for the Purchase, its parent's (this) + // ref-count is added. + // If the Release is called and + // when the reference counter reaches zero, this metadata which + // acts as parent will be deleted. The destructor of this + // metadata will delete the icon because this node owns it. + } + else if ( isPurchaseSupported && iPurchase ) + { + DLINFO(("Purchase is supported -> internalize.")); + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + iPurchase->InternalizeL(); + } + else if ( !isPurchaseSupported && iPurchase ) + { + DLTRACE(("Purchase not supported -> remove.")); + if ( iPurchase->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iPurchase; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iPurchase = NULL; + } + + DLTRACEOUT(("")); + } + +void CNcdNodeMetadataProxy::InternalizeUriContentL() + { + DLTRACEIN(("")); + + if ( iUriContent == NULL ) + { + DLINFO(("uri content did not exist")); + + // Check if the metadata exists in the server side. + // The uri content is part of the metadata. + // Update the information if it exists. + TInt uriHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdUriContentHandle, + KNullDesC, + uriHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("uri content did not exist in server side")); + + // Because uri content did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Uri content existed in the server side")); + + // Now we can create the uri content object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iUriContent = CNcdNodeUriContentProxy::NewL( ClientServerSession(), + uriHandle, + *this ); + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + iUriContent->InternalizeL(); + } + + DLTRACEOUT(("")); + } + +void CNcdNodeMetadataProxy::InternalizeContentInfoL() + { + DLTRACEIN(("")); + + if ( iContentInfo == NULL ) + { + DLINFO(("content info did not exist")); + + // Check if the metadata exists in the server side. + // The content info is part of the metadata. + // Update the information if it exists. + TInt infoHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdContentInfoHandle, + KNullDesC, + infoHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Content info did not exist in server side")); + + // Because content info did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Content info existed in the server side")); + + // Now we can create the content info object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iContentInfo = CNcdNodeContentInfoProxy::NewL( ClientServerSession(), + infoHandle, + *this ); + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iContentInfo->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("Content info was obsolete")); + if ( iContentInfo->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iContentInfo; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iContentInfo = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + DLTRACEOUT(("")); + } + +void CNcdNodeMetadataProxy::InternalizeInstallL() + { + DLTRACEIN(("")); + + if ( iInstall == NULL ) + { + DLINFO(("Node install was not set. Set it now.")); + TInt installHandle( 0 ); + + // Get the handle for the install. + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdInstallHandle, + KNullDesC, + installHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Install info did not exist in server side")); + + // Because content info did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Handle: %i", installHandle)); + + // Now we can create the install object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iInstall = CNcdNodeInstallProxy::NewL( ClientServerSession(), + installHandle, + *this ); + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + iInstall->InternalizeL(); + } + + DLTRACEOUT(("")); + } + +void CNcdNodeMetadataProxy::InternalizePreviewL() + { + DLTRACEIN(("")); + + if ( iPreview == NULL ) + { + DLINFO(("Preview did not exist")); + + TInt previewHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdPreviewHandle, + KNullDesC, + previewHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLINFO(("Preview did not exist in server side")); + + // Because preview did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLINFO(("Preview existed in the server side")); + + // Now we can create the preview object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + // Also, notice that if the proxy object leaves during the construction + // the destructor automatically releases the handle from the server side. + iPreview = CNcdNodePreviewProxy::NewL( ClientServerSession(), + previewHandle, + *this ); + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iPreview->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("Preview was obsolete")); + if ( iPreview->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iPreview; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iPreview = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + DLTRACEOUT(("")); + } + + +void CNcdNodeMetadataProxy::InternalizeSkinL() + { + DLTRACEIN(("")); + + if( iSkin == NULL ) + { + DLTRACE(("Skin did not exist")); + + TInt skinHandle( 0 ); + + TInt handleError = + ClientServerSession(). + SendSync( NcdNodeFunctionIds::ENcdSkinHandle, + KNullDesC, + skinHandle, + Handle() ); + + if ( handleError == KErrNotFound ) + { + DLTRACE(("Skin did not exist in server side")); + + // Because skin did not exist in the server side + // Nothing to do here. + return; + } + else + { + // If error occurred then leave + User::LeaveIfError( handleError ); + } + + DLTRACE(("Skin existed in the server side")); + + // Now we can create the skin object. + // Notice that this object will add its own interfaces to the + // querylist when the object is created. + iSkin = CNcdNodeSkinProxy::NewL( ClientServerSession(), + skinHandle, + *this ); + // Skin ref counter is not increased here. + // So, it will be zero until somebody asks for the skin. + // If the Release is called and + // when the reference counter reaches zero, this node which + // acts as parent will be deleted. The destructor of this + // node will delete the skin because this node owns it. + } + else + { + // Notice that that if the proxy object was created above, + // it internalizes itself during construction. So, call + // the internalize here only if the object was not constructed + // above. + // Proxy object existed. + // So, internalize it with new data. + TRAPD( trapError, iSkin->InternalizeL() ); + if ( trapError == KNcdErrorObsolete ) + { + DLINFO(("Skin was obsolete")); + if ( iSkin->MyTotalRefCount() == 0 ) + { + DLINFO(("Total reference count is zero. So, delete object.")) + // Because total reference count is zero and the object is obsolete, + // it should be deleted. + delete iSkin; + } + + // Set object pointer to NULL because it has become obsolete. + // It will be deleted automatically when the users release it + // or it may have already been deleted above if nobody was using it. + iSkin = NULL; + } + else + { + // Let this function leave if there was another error. + User::LeaveIfError( trapError ); + } + } + DLTRACEOUT(("")); + } + + +void CNcdNodeMetadataProxy::InternalizeActivateL() + { + DLTRACEIN(("")); + + if ( iInstall != NULL + && iInstall->IsInstalledL() + && ( iInstall->IsPurpose( ENcdItemPurposeRingtone ) + || iInstall->IsPurpose( ENcdItemPurposeWallpaper ) + || iInstall->IsPurpose( ENcdItemPurposeTheme ) ) ) + { + // Because install interface exists and something has been installed, + // there may be something to activate. Note that items should be installed + // before they can be activated. + if ( iActivate == NULL ) + { + // Create activate interface object only if it does not already exist. + iActivate = CNcdNodeActivate::NewL( *this ); + } + } + else if ( iActivate != NULL ) + { + // Because install information did not exist or the item does not have + // anything to activate, activate option should not exist either. + // Destructor takes care of the removing the interface + // from the interface list. + delete iActivate; + iActivate = NULL; + } + + DLTRACEOUT(("")); + } + + + +