--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ncdengine/provider/client/src/ncdrootnodeproxy.cpp Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,286 @@
+/*
+* 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 CNcdRootNodeProxy class implementation
+*
+*/
+
+
+#include "ncdrootnodeproxy.h"
+#include "catalogsclientserver.h"
+#include "ncdnodemanagerproxy.h"
+#include "ncdoperationmanagerproxy.h"
+#include "ncdnodeidentifier.h"
+#include "catalogsdebug.h"
+#include "ncdnodefunctionids.h"
+#include "catalogsinterfaceidentifier.h"
+#include "ncdloadnodeoperationproxy.h"
+#include "ncdchildentity.h"
+#include "ncderrors.h"
+
+
+// ======== PUBLIC MEMBER FUNCTIONS ========
+
+CNcdRootNodeProxy* CNcdRootNodeProxy::NewL( MCatalogsClientServer& aSession,
+ TInt aHandle,
+ CNcdNodeManagerProxy& aNodeManager,
+ CNcdOperationManagerProxy& aOperationManager,
+ CNcdFavoriteManagerProxy& aFavoriteManager )
+ {
+ CNcdRootNodeProxy* self =
+ CNcdRootNodeProxy::NewLC(
+ aSession, aHandle, aNodeManager, aOperationManager, aFavoriteManager );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+CNcdRootNodeProxy* CNcdRootNodeProxy::NewLC( MCatalogsClientServer& aSession,
+ TInt aHandle,
+ CNcdNodeManagerProxy& aNodeManager,
+ CNcdOperationManagerProxy& aOperationManager,
+ CNcdFavoriteManagerProxy& aFavoriteManager )
+ {
+ CNcdRootNodeProxy* self =
+ new( ELeave ) CNcdRootNodeProxy(
+ aSession, aHandle, aNodeManager, aOperationManager, aFavoriteManager );
+ // Using PushL because the object does not have any references yet
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+
+CNcdRootNodeProxy::CNcdRootNodeProxy( MCatalogsClientServer& aSession,
+ TInt aHandle,
+ CNcdNodeManagerProxy& aNodeManager,
+ CNcdOperationManagerProxy& aOperationManager,
+ CNcdFavoriteManagerProxy& aFavoriteManager )
+: CNcdParentOfTransparentNodeProxy(
+ aSession, aHandle, aNodeManager, aOperationManager, aFavoriteManager )
+ {
+ }
+
+
+void CNcdRootNodeProxy::ConstructL()
+ {
+ CNcdParentOfTransparentNodeProxy::ConstructL();
+ }
+
+
+CNcdRootNodeProxy::~CNcdRootNodeProxy()
+ {
+ }
+
+
+TInt CNcdRootNodeProxy::ChildCount() const
+ {
+ return iChildren.Count();
+ }
+
+
+MNcdNode* CNcdRootNodeProxy::ChildL( TInt aIndex )
+ {
+ DLTRACEIN(( _L("This parent: %S, %S"), &Namespace(), &Id() ));
+
+
+ if ( aIndex < 0 || aIndex >= iChildren.Count() )
+ {
+ // Nothing to be done
+ DLERROR(( "Index error. child count: %d Given index: %d",
+ iChildren.Count(), aIndex ));
+ DASSERT( EFalse );
+ User::Leave( KErrArgument );
+ }
+
+ const CNcdNodeIdentifier* child = &iChildren[aIndex]->Identifier();
+
+ MNcdNode* node( NULL );
+
+ TRAPD( err, node = &NodeManager().NodeL( *child ) );
+
+ if ( err == KErrNotFound )
+ {
+ return NULL;
+ }
+
+ User::LeaveIfError( err );
+
+ // Increase the reference counter by one
+ node->AddRef();
+
+ DLTRACEOUT((""));
+
+ return node;
+ }
+
+MNcdNode::TState CNcdRootNodeProxy::State() const
+ {
+ DLTRACEIN((""));
+
+ // Check if the link handle has been set, which means that also
+ // link data has been internalized. Root node does not contain
+ // metadata so it does not need to be checked.
+ // The child count is also checked because in some situations when root loading
+ // is cancelled the link handle may be set, but the children are not inserted to
+ // the root child list. So, the root should have children to be in initialized mode.
+ if ( LinkHandleSet() && ChildCount() > 0 )
+ {
+ DLTRACE(("State was initialized"));
+ // If state was initialized we have to check if the state
+ // has acutally expired already
+ TTime now;
+ now.HomeTime();
+
+ DLTRACE(("now time: %d", now.Int64() ));
+ DLTRACE(("expired time: %d", ExpiredTime().Int64() ));
+
+ // We can just compare the times here. Server side
+ // inserts the maximum value for the expired time if the
+ // protocol has set never expire value for the validity delta.
+ TBool isExpired = ( now > ExpiredTime() );
+ TInt err = KErrNone;
+
+ if ( !isExpired )
+ {
+ TRAP( err, isExpired = IsTransparentChildExpiredL() );
+ }
+
+ if ( isExpired || err != KErrNone )
+ {
+ DLTRACEOUT(("Expired"));
+ return MNcdNode::EStateExpired;
+ }
+
+ DLTRACEOUT(("Initialized"));
+ return MNcdNode::EStateInitialized;
+ }
+ else
+ {
+ // Node has not been initialized.
+ DLTRACEOUT(("Not intialized"));
+ return MNcdNode::EStateNotInitialized;
+ }
+
+ }
+
+
+MNcdLoadNodeOperation* CNcdRootNodeProxy::LoadL( MNcdLoadNodeOperationObserver& aObserver )
+ {
+ DLTRACEIN((""));
+
+ CNcdLoadNodeOperationProxy* operation( NULL );
+
+ operation =
+ OperationManager().
+ CreateLoadRootNodeOperationL( *this );
+
+ operation->AddObserverL( this );
+ operation->AddObserverL( &aObserver );
+
+ DLTRACEOUT((""));
+
+ return operation;
+ }
+
+
+MNcdLoadNodeOperation* CNcdRootNodeProxy::LoadChildrenL( TInt /*aIndex*/,
+ TInt /*aSize*/,
+ TNcdChildLoadMode aMode,
+ MNcdLoadNodeOperationObserver& aObserver )
+ {
+ DLTRACEIN(("Root load mode: %d", aMode));
+
+ // Root is a special case when children are loaded.
+ // Because root operation always load its children same time normal LoadL is called
+ // for the root, the children of the root are always up to date.
+ // The only exception is, if the schemes are added to the root list separately.
+ // Because of the possible schemes, this function is overloaded and the
+ // staring index is set to be zero and the size has to be the whole child array size which
+ // includes the possible scheme.
+
+ CNcdLoadNodeOperationProxy* operation =
+ OperationManager().CreateLoadNodeOperationL( *this, ETrue,
+ ServerChildCount(),
+ 0,
+ 1,
+ aMode );
+
+ if( operation == NULL )
+ {
+ DLTRACEOUT(("NULL"));
+ return NULL;
+ }
+
+ operation->AddObserverL( this );
+ operation->AddObserverL( &aObserver );
+
+ DLTRACEOUT((""));
+
+ return operation;
+ }
+
+
+RCatalogsArray<MNcdOperation> CNcdRootNodeProxy::OperationsL() const
+ {
+ DLTRACEIN((""));
+ RCatalogsArray<MNcdOperation> operations;
+ CleanupClosePushL( operations );
+
+ // Operations will be get differently for root node, because root
+ // node does not have metadata.
+
+ // Get the original array and insert its content to catalogs array.
+ // Also, increase the reference counter for the items.
+ const RPointerArray<MNcdOperation>& origArray = OperationManager().Operations();
+ const MNcdNode* thisNode( this );
+ MNcdOperation* oper( NULL );
+ MNcdNode* node( NULL );
+
+ for ( TInt i = 0; i < origArray.Count(); ++i )
+ {
+ oper = origArray[ i ];
+
+ // Notice that node ref count is increased. So, release it when done.
+ node = oper->Node();
+ CleanupReleasePushL( *node );
+
+ if( node == thisNode )
+ {
+ operations.AppendL( oper );
+ oper->AddRef();
+ }
+
+ CleanupStack::PopAndDestroy( node );
+ }
+
+ CleanupStack::Pop( &operations );
+
+ DLTRACEOUT(( "" ));
+ return operations;
+ }
+
+
+void CNcdRootNodeProxy::OperationComplete( MNcdLoadNodeOperation& /*aOperation*/,
+ TInt aError )
+ {
+ DLTRACEIN((""));
+ // Should all the error code checks be removed and always internalize root node?
+ if( aError == KErrNone || aError == KNcdErrorSomeCatalogsFailedToLoad ||
+ aError == KErrCancel )
+ {
+ // Because operation went ok. Update the node data.
+ TRAP_IGNORE( InternalizeL() );
+ }
+ DLTRACEOUT((""));
+ }
+