--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ncdengine/provider/client/src/ncdbundlefolderproxy.cpp Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,313 @@
+/*
+* 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 CNcdBundleFolderProxy class implementation
+*
+*/
+
+
+#include "ncdbundlefolderproxy.h"
+#include "ncdoperationmanagerproxy.h"
+#include "ncdloadnodeoperationproxy.h"
+#include "catalogsinterfaceidentifier.h"
+#include "catalogsdebug.h"
+#include "catalogsutils.h"
+#include "ncdchildentity.h"
+#include "ncdnodemanagerproxy.h"
+#include "ncdchildloadmode.h"
+#include "ncdcapabilities.h"
+
+CNcdBundleFolderProxy* CNcdBundleFolderProxy::NewL(
+ MCatalogsClientServer& aSession,
+ TInt aHandle,
+ CNcdNodeManagerProxy& aNodeManager,
+ CNcdOperationManagerProxy& aOperationManager,
+ CNcdFavoriteManagerProxy& aFavoriteManager )
+ {
+ DLTRACEIN((""));
+ CNcdBundleFolderProxy* self = NewLC(
+ aSession, aHandle, aNodeManager, aOperationManager, aFavoriteManager );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+CNcdBundleFolderProxy* CNcdBundleFolderProxy::NewLC(
+ MCatalogsClientServer& aSession,
+ TInt aHandle,
+ CNcdNodeManagerProxy& aNodeManager,
+ CNcdOperationManagerProxy& aOperationManager,
+ CNcdFavoriteManagerProxy& aFavoriteManager )
+ {
+ DLTRACEIN((""));
+ CNcdBundleFolderProxy* self = new ( ELeave ) CNcdBundleFolderProxy(
+ aSession, aHandle, aNodeManager, aOperationManager, aFavoriteManager );
+ // Using PushL because the object does not have any references yet
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+CNcdBundleFolderProxy::CNcdBundleFolderProxy(
+ MCatalogsClientServer& aSession,
+ TInt aHandle,
+ CNcdNodeManagerProxy& aNodeManager,
+ CNcdOperationManagerProxy& aOperationManager,
+ CNcdFavoriteManagerProxy& aFavoriteManager )
+: CNcdParentOfTransparentNodeProxy( aSession,
+ aHandle,
+ aNodeManager,
+ aOperationManager,
+ aFavoriteManager )
+ {
+ }
+
+CNcdBundleFolderProxy::~CNcdBundleFolderProxy()
+ {
+ delete iViewType;
+ }
+
+MNcdNode::TState CNcdBundleFolderProxy::State() const
+ {
+ DLTRACEIN((_L("Node namespace=%S, id=%S"), &Namespace(), &Id() ));
+
+ // Check if the link handle has been set, which means that also
+ // link data has been internalized. Also, check if the metadata
+ // exists, which means that metadata has also been internalized.
+ if ( LinkHandleSet()
+ && Metadata() != NULL )
+ {
+ DLINFO(("State was initialized"));
+ // If state was initialized we have to check if the state
+ // has acutally expired already
+ TTime now;
+ now.HomeTime();
+
+ DLINFO(("now time: %Ld", now.Int64() ));
+ DLINFO(("expired time: %Ld", 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 initialized"));
+ return MNcdNode::EStateNotInitialized;
+ }
+ }
+
+TInt CNcdBundleFolderProxy::ChildCount() const
+ {
+ return iChildren.Count();
+ }
+
+
+MNcdNode* CNcdBundleFolderProxy::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;
+ }
+
+MNcdLoadNodeOperation* CNcdBundleFolderProxy::LoadChildrenL(
+ TInt aIndex,
+ TInt aSize,
+ TNcdChildLoadMode aMode,
+ MNcdLoadNodeOperationObserver& aObserver )
+ {
+ DLTRACEIN((""));
+
+ if( aSize < 1 || aIndex < 0 || ( aMode == ELoadMetadata && aIndex + aSize > ChildCount() ) )
+ {
+ // Nothing to be done
+ DLERROR(( "Argument error. ChildCount: %d Given index: %d, size: %d",
+ ChildCount(), aIndex, aSize ));
+ DASSERT( EFalse );
+ User::Leave( KErrArgument );
+ }
+
+ DLTRACE(( _L("Node: %S, %S"), &Namespace(), &Id() ));
+
+ if( aMode == ELoadMetadata )
+ {
+ // Child metadata can be loaded in a regular load op.
+ // Notice, because this node can be parent of transparent nodes
+ // we have to make sure that the indexing is correct. (Transparent folders
+ // may have been replaced by their children, and then the indexing will not
+ // match the server side.)
+ // Note that start index is always 0 for bundles
+ 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;
+ }
+ else
+ {
+ // Everything else needs to be loaded via root load op
+ return LoadL( aObserver );
+ }
+ }
+
+
+MNcdLoadNodeOperation* CNcdBundleFolderProxy::LoadL(
+ MNcdLoadNodeOperationObserver& aObserver )
+ {
+ DLTRACEIN((""));
+
+ CNcdLoadNodeOperationProxy* operation( NULL );
+
+ // bundle's are loaded with load bundle op
+ operation =
+ OperationManager().CreateLoadBundleNodeOperationL( *this );
+
+ operation->AddObserverL( this );
+ operation->AddObserverL( &aObserver );
+
+ return operation;
+ }
+
+void CNcdBundleFolderProxy::ConstructL()
+ {
+ DLTRACEIN((("this: %x"), this ));
+ AssignDesL( iViewType, KNullDesC() );
+ CNcdParentOfTransparentNodeProxy::ConstructL();
+
+ // Add the interface information to the list
+ MNcdBundle* bundle( this );
+ AddInterfaceL(
+ CCatalogsInterfaceIdentifier::NewL(
+ bundle, this, MNcdBundle::KInterfaceUid ) );
+ }
+
+const TDesC& CNcdBundleFolderProxy::ViewType() const
+ {
+ DLTRACEIN((_L("this: %x, viewtype: %S"), this, iViewType));
+ return *iViewType;
+ }
+
+
+
+void CNcdBundleFolderProxy::InternalizeL()
+ {
+ DLTRACEIN((("this: %x"), this));
+
+ // First call the parent internalizator. So, all the parent stuff will
+ // be initialized before folder specific data.
+ CNcdParentOfTransparentNodeProxy::InternalizeL();
+
+ DLTRACEOUT((""));
+ }
+
+
+
+void CNcdBundleFolderProxy::InternalizeNodeDataL( RReadStream& aStream )
+ {
+ DLTRACEIN((""));
+
+ // First internalize parent data
+ CNcdParentOfTransparentNodeProxy::InternalizeNodeDataL( aStream );
+
+ InternalizeDesL( iViewType, aStream );
+
+ DLINFO((_L("this: %x, viewtype: %S"), this, iViewType));
+
+ DLTRACEOUT((""));
+ }
+
+void CNcdBundleFolderProxy::InternalizeNodeLinkDataL( RReadStream& aStream )
+ {
+ DLTRACEIN((""));
+
+ // First internalize parent data
+ CNcdParentOfTransparentNodeProxy::InternalizeNodeLinkDataL( aStream );
+
+ DLTRACEOUT((""));
+ }
+
+TBool CNcdBundleFolderProxy::IsSearchSupportedL()
+ {
+ DLTRACEIN((""));
+ // If one of the bundles children has search capability set, then this
+ // bundle supports searching.
+ // NOTE: Search will only be conducted for children with search capability set.
+ for( TInt i = 0 ; i < iChildren.Count() ; i++ )
+ {
+ if( NodeManager().IsCapabilitySupportedL( iChildren[i]->Identifier(),
+ NcdCapabilities::KSearch ) )
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }