diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/client/src/ncdnodeupgradeproxy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/client/src/ncdnodeupgradeproxy.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,385 @@ +/* +* 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 CNcdNodeUpgradeProxy class implementation +* +*/ + + +#include "ncdnodeupgradeproxy.h" +#include "ncdnodemetadataproxy.h" +#include "ncdnodemanagerproxy.h" +#include "ncdnodeproxy.h" +#include "ncdnodemanagerproxy.h" +#include "catalogsclientserver.h" +#include "ncdnodedependencyinfoimpl.h" +#include "ncddependencyinfo.h" +#include "ncdnodefunctionids.h" +#include "ncdnodeclassids.h" +#include "catalogsinterfaceidentifier.h" +#include "ncdnodeidentifier.h" +#include "catalogsutils.h" +#include "catalogsdebug.h" +#include "ncderrors.h" +#include "ncdattributes.h" +#include "ncdnodeupgradeimpl.h" // TUpgradeData + + +// ======== PUBLIC MEMBER FUNCTIONS ======== + +CNcdNodeUpgradeProxy::CNcdNodeUpgradeProxy( + MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeMetadataProxy& aMetadata ) + : CNcdInterfaceBaseProxy( aSession, aHandle, &aMetadata ), + iNodeManager( aMetadata.Node().NodeManager() ), + iUpgradeType( MNcdNodeUpgrade::EUpgradeNotAvailable ) + { + } + + +void CNcdNodeUpgradeProxy::ConstructL() + { + // Register the interface + MNcdNodeUpgrade* interface( this ); + AddInterfaceL( + CCatalogsInterfaceIdentifier::NewL( interface, this, MNcdNodeUpgrade::KInterfaceUid ) ); + + // Let the construction leave if we do not get the data from the server. + InternalizeL(); + } + + +CNcdNodeUpgradeProxy* CNcdNodeUpgradeProxy::NewL( + MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeMetadataProxy& aMetadata ) + { + CNcdNodeUpgradeProxy* self = + CNcdNodeUpgradeProxy::NewLC( aSession, aHandle, aMetadata ); + CleanupStack::Pop( self ); + return self; + } + +CNcdNodeUpgradeProxy* CNcdNodeUpgradeProxy::NewLC( + MCatalogsClientServer& aSession, + TInt aHandle, + CNcdNodeMetadataProxy& aMetadata ) + { + CNcdNodeUpgradeProxy* self = + new( ELeave ) CNcdNodeUpgradeProxy( aSession, aHandle, aMetadata ); + // Using PushL because the object does not have any references yet + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + +CNcdNodeUpgradeProxy::~CNcdNodeUpgradeProxy() + { + // 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( MNcdNodeUpgrade::KInterfaceUid ); + + + // Delete member variables here + // Do not delete manager because + // this object does not own it. + + // Casting is safe here because only this class creates the objects + // that are inserted into the array. + ResetAndDestroyWithCast( iUpgradeTargets ); + + delete iUpgradeData; + } + + +CNcdNodeManagerProxy& CNcdNodeUpgradeProxy::NodeManager() const + { + return iNodeManager; + } + + +void CNcdNodeUpgradeProxy::InternalizeL() + { + DLTRACEIN(("")); + + HBufC8* 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. + // Get all the data that is necessary to internalize this object + // from the server side. + TInt error( + ClientServerSession(). + SendSyncAlloc( NcdNodeFunctionIds::ENcdInternalize, + KNullDesC8, + data, + Handle(), + 0 ) ); + + if ( error == KNcdErrorObsolete ) + { + DLINFO(("Upgrade was obsolete")); + // Remove interfaces implemented by this class from the top parent interface list. + // So, the interface list is up to date after this object is removed + // from its top parent. + RemoveInterface( MNcdNodeUpgrade::KInterfaceUid ); + // Remove from the parent + RemoveFromParent(); + // Now update the interface for this object just in case somebody needs it. + // Register the interface + MNcdNodeUpgrade* interface( this ); + AddInterfaceL( + CCatalogsInterfaceIdentifier::NewL( interface, this, MNcdNodeUpgrade::KInterfaceUid ) ); + + } + else if ( error == KErrNotFound ) + { + DLTRACE(("Upgrade not available anymore")); + // Reset upgrade type so that the interface user knows that there's + // no more upgrade available + iUpgradeType = MNcdNodeUpgrade::EUpgradeNotAvailable; + } + + // If error occurred during data transfer, leave here and forward the error. + User::LeaveIfError( error ); + + if ( data == NULL ) + { + DLERROR(("")); + 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 ); + + DLTRACEOUT(("")); + } + + +// MNcdNodeUpgrade functions + +const TDesC& CNcdNodeUpgradeProxy::Name() const + { + // Even though we may have multiple possibilities in the array. + // The API function only wants one. So choose the first one here. + if ( iUpgradeTargets.Count() == 0 ) + { + return KNullDesC(); + } + + return iUpgradeTargets[0]->Name(); + } + + +TUid CNcdNodeUpgradeProxy::Uid() const + { + DLTRACEIN(("")); + + // Upgrades some content, return uid for that content + if ( iUpgradeData && + iUpgradeData->AttributeType( CNcdNodeUpgrade::EUpgradeDataUid ) == + CNcdAttributes::EAttributeTypeInt32 ) + { + DLTRACEOUT(("Return UID for content upgrade")) + return TUid::Uid( iUpgradeData->AttributeInt32( + CNcdNodeUpgrade::EUpgradeDataUid ) ); + } + + // Even though we may have multiple possibilities in the array. + // The API function only wants one. So choose the first one here. + + if ( iUpgradeTargets.Count() == 0 ) + { + return TUid::Null(); + } + + + return iUpgradeTargets[0]->Uid(); + } + + +const TDesC& CNcdNodeUpgradeProxy::Version() const + { + DLTRACEIN(("")); + if ( iUpgradeData && + iUpgradeData->AttributeType( CNcdNodeUpgrade::EUpgradeDataVersion ) == + CNcdAttributes::EAttributeTypeString16 ) + { + DLTRACEOUT(("Return version for content upgrade")) + return iUpgradeData->AttributeString16( + CNcdNodeUpgrade::EUpgradeDataVersion ); + } + + + // Even though we may have multiple possibilities in the array. + // The API function only wants one. So choose the first one here. + + if ( iUpgradeTargets.Count() == 0 ) + { + return KNullDesC(); + } + + return iUpgradeTargets[0]->Version(); + } + + +MNcdNode* CNcdNodeUpgradeProxy::UpgradeableNodeL() const + { + DLTRACEIN(("")); + + // Even though we may have multiple possibilities in the array. + // The API function only wants one. So choose the first one here. + + if ( iUpgradeTargets.Count() == 0 ) + { + return NULL; + } + + return iUpgradeTargets[0]->DependencyNodeL(); + } + + + +MNcdNodeUpgrade::TUpgradeType CNcdNodeUpgradeProxy::UpgradeType() const + { + return iUpgradeType; + } + + +// Other functions + +const RPointerArray& CNcdNodeUpgradeProxy::UpgradeTargets() const + { + return iUpgradeTargets; + } + + +void CNcdNodeUpgradeProxy::InternalizeDataL( RReadStream& aStream ) + { + DLTRACEIN(("")); + + // Use catalogsutils.h functions to internalize + // memebervariables according to the data received + // from the server. + // Make sure that the variables are set here in the same + // order as they are externalized in the server side. + // Small mistake here messes up everything! + + // First read the class id. Because, it is the first thing in the stream. + TInt classId( aStream.ReadInt32L() ); + + if ( classId != NcdNodeClassIds::ENcdNodeUpgradeClassId ) + { + // classId is not recognized + DLERROR(("Class id was not recognized!")); + // For testing purposes assert here + DASSERT( EFalse ); + + // Otherwise leave is adequate + User::Leave( KErrCorrupt ); + } + + InternalizeUpgradeArrayL( aStream ); + + delete iUpgradeData; + iUpgradeData = NULL; + + TBool upgradeDataExists = aStream.ReadInt8L(); + if ( upgradeDataExists ) + { + iUpgradeData = CNcdAttributes::NewL( + aStream, + CNcdNodeUpgrade::EUpgradeDataInternal, + 0 ); + } + + if ( !iUpgradeData && !iUpgradeTargets.Count() ) + { + DLERROR(("Corrupt data, leaving")); + User::Leave( KErrCorrupt ); + } + + RefreshUpgradeType(); + DLTRACEOUT(("")); + } + + +void CNcdNodeUpgradeProxy::InternalizeUpgradeArrayL( RReadStream& aStream ) + { + DLTRACEIN(("")); + + // Casting is safe here because only this class creates the objects + // that are inserted into the array. + ResetAndDestroyWithCast( iUpgradeTargets ); + + // First get the node dependency information that is sent from the server + // and then convert it to the proxy side dependency information object + // that is inserted into the array. + TInt count( aStream.ReadInt32L() ); + CNcdDependencyInfo* upgradeInfo( NULL ); + CNcdNodeDependencyInfo* info( NULL ); + for( TInt i = 0; i < count; ++i ) + { + upgradeInfo = CNcdDependencyInfo::NewLC( aStream ); + info = CNcdNodeDependencyInfo::NewLC( *upgradeInfo, NodeManager() ); + iUpgradeTargets.AppendL( info ); + // Ownership was transferred to the array + CleanupStack::Pop( info ); + CleanupStack::PopAndDestroy( upgradeInfo ); + } + + // Second get the content dependency information + count = aStream.ReadInt32L(); + upgradeInfo = NULL; + info = NULL; + for( TInt i = 0; i < count; ++i ) + { + upgradeInfo = CNcdDependencyInfo::NewLC( aStream ); + info = CNcdNodeDependencyInfo::NewLC( *upgradeInfo, NodeManager() ); + iUpgradeTargets.AppendL( info ); + CleanupStack::Pop( info ); + CleanupStack::PopAndDestroy( upgradeInfo ); + } + + DLTRACEOUT(("")); + } + + +void CNcdNodeUpgradeProxy::RefreshUpgradeType() + { + DLTRACEIN(("")); + if ( iUpgradeData || + !static_cast( + iUpgradeTargets[0] )->Identifier() ) + { + DLTRACE(("Upgrade content")); + iUpgradeType = MNcdNodeUpgrade::EUpgradeContent; + } + else + { + DLTRACE(("Upgrade node")); + iUpgradeType = MNcdNodeUpgrade::EUpgradeNode; + } + }