diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/client/src/ncdfavoritemanagerproxy.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ncdengine/provider/client/src/ncdfavoritemanagerproxy.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,498 @@
+/*
+* 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 CNcdFavoriteManagerProxy class
+*
+*/
+
+
+#include <s32mem.h>
+
+#include "ncdfavoritemanagerproxy.h"
+#include "catalogsdebug.h"
+#include "catalogsinterfaceidentifier.h"
+#include "catalogsclientserver.h"
+#include "ncdnodefunctionids.h"
+#include "ncdnodeidentifier.h"
+#include "catalogsconstants.h"
+#include "ncdnodemanagerproxy.h"
+#include "ncdnodeproxy.h"
+#include "catalogsutils.h"
+#include "ncdnodedisclaimerproxy.h"
+#include "ncdnodeidentifiereditor.h"
+#include "ncdnodeidentifierutils.h"
+
+CNcdFavoriteManagerProxy* CNcdFavoriteManagerProxy::NewL(
+    MCatalogsClientServer& aSession,
+    TInt aHandle,
+    CCatalogsInterfaceBase* aParent,
+    CNcdNodeManagerProxy& aNodeManager ) 
+    {
+    CNcdFavoriteManagerProxy* self = NewLC(
+        aSession, aHandle, aParent, aNodeManager );
+    CleanupStack::Pop( self );
+    return self;
+    }
+    
+CNcdFavoriteManagerProxy* CNcdFavoriteManagerProxy::NewLC(
+    MCatalogsClientServer& aSession,
+    TInt aHandle,
+    CCatalogsInterfaceBase* aParent,
+    CNcdNodeManagerProxy& aNodeManager ) 
+    {
+    CNcdFavoriteManagerProxy* self =
+        new( ELeave ) CNcdFavoriteManagerProxy(
+            aSession, aHandle, aParent, aNodeManager );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    return self;
+    }
+    
+CNcdFavoriteManagerProxy::CNcdFavoriteManagerProxy(
+    MCatalogsClientServer& aSession,
+    TInt aHandle,
+    CCatalogsInterfaceBase* aParent,
+    CNcdNodeManagerProxy& aNodeManager )
+    : CNcdInterfaceBaseProxy( aSession, aHandle, aParent ),
+      iNodeManager( aNodeManager ) 
+    {
+    }
+    
+CNcdFavoriteManagerProxy::~CNcdFavoriteManagerProxy() 
+    {
+    DLTRACEIN((""));
+    iFavoriteNodes.ResetAndDestroy();
+    }
+    
+
+TBool CNcdFavoriteManagerProxy::IsFavoriteL(
+    const CNcdNodeIdentifier& aNodeIdentifier ) const
+    {
+    DLTRACEIN((""));
+    
+    // If the metadata is favorite, the node itself is favorite.
+    CNcdNodeIdentifier* actualFavId = ActualFavoriteIdentifierL( aNodeIdentifier );
+    return actualFavId != NULL;
+    }
+
+
+void CNcdFavoriteManagerProxy::AddToFavoritesL(
+    const CNcdNodeIdentifier& aNodeIdentifier, TBool aRemoveOnDisconnect ) 
+    {
+    DLTRACEIN((""));
+    
+    // Check if the metadata is already added as favorite.
+    CNcdNodeIdentifier* metadataId =
+        NcdNodeIdentifierEditor::CreateMetaDataIdentifierLC( aNodeIdentifier );
+    if ( FavoriteNodeByMetaDataL( *metadataId ) ) 
+        {
+        // The metadata is already favorite, do nothing.
+        CleanupStack::PopAndDestroy( metadataId );
+        return;
+        }        
+    
+    CBufBase* buf = CBufFlat::NewL( KBufExpandSize );
+    CleanupStack::PushL( buf );
+
+    RBufWriteStream stream( *buf );
+    CleanupClosePushL( stream );
+    
+    aNodeIdentifier.ExternalizeL( stream );
+    stream.WriteInt8L( aRemoveOnDisconnect );
+    
+    CleanupStack::PopAndDestroy( &stream );
+    
+    TInt output;
+    
+    // Send the message to server side.
+    User::LeaveIfError(
+        ClientServerSession().SendSync(
+            NcdNodeFunctionIds::ENcdFavoriteManagerAddFavorite,
+            buf->Ptr( 0 ),
+            output,
+            Handle() ) );
+            
+    CleanupStack::PopAndDestroy( buf );            
+    
+    // Add the identifier to proxy side list too.
+    CNcdNodeIdentifier* copy = CNcdNodeIdentifier::NewLC( aNodeIdentifier );
+    iFavoriteNodes.AppendL( copy );
+    CleanupStack::Pop( copy );    
+    CleanupStack::PopAndDestroy( metadataId );
+    
+    // In principle, the other node proxys having the same metadata should
+    // be provided with the MNcdNodeFavorite interface as well.
+    }
+    
+    
+void CNcdFavoriteManagerProxy::RemoveFromFavoritesL(
+    const CNcdNodeIdentifier& aNodeIdentifier ) 
+    {
+    DLTRACEIN((""));
+    
+    // The actual node to remove may have different id but same metadata,
+    // get the actual favorite node.
+    CNcdNodeIdentifier* actualIdentifier = ActualFavoriteIdentifierL( aNodeIdentifier );
+    if ( !actualIdentifier ) 
+        {
+        // Nothing to do, the node is not favourite.
+        return;
+        }
+    
+    CBufBase* buf = CBufFlat::NewL( KBufExpandSize );
+    CleanupStack::PushL( buf );
+
+    RBufWriteStream stream( *buf );
+    CleanupClosePushL( stream );
+    
+    actualIdentifier->ExternalizeL( stream );
+    
+    CleanupStack::PopAndDestroy( &stream );
+    
+    TInt output;
+    
+    // Send the message to server side.
+    User::LeaveIfError(
+        ClientServerSession().SendSync(
+            NcdNodeFunctionIds::ENcdFavoriteManagerRemoveFavorite,
+            buf->Ptr( 0 ),
+            output,
+            Handle() ) );
+            
+    CleanupStack::PopAndDestroy( buf );
+    
+    // Remove the identifier from proxy side list too.
+    TInt nodeCount = iFavoriteNodes.Count();
+    for ( TInt i = 0; i < nodeCount; i++ ) 
+        {
+        if ( iFavoriteNodes[i]->Equals( *actualIdentifier ) ) 
+            {
+            delete iFavoriteNodes[i];
+            iFavoriteNodes.Remove( i );
+            break;
+            }
+        }
+    
+    // In principle, the other node proxys having the same metadata should
+    // not have the MNcdNodeFavorite interface after this, so it should be removed.
+    }
+    
+    
+void CNcdFavoriteManagerProxy::SetNodeDisclaimerL(
+    const CNcdNodeIdentifier& aFavoriteNodeIdentifier,
+    MNcdNode* aDisclaimerOwner ) 
+    {
+    DLTRACEIN((""));
+    
+    // If the node is not favorite, leave
+    if ( !IsFavoriteL( aFavoriteNodeIdentifier ) ) 
+        {
+        User::Leave( KErrArgument );
+        }
+        
+    CNcdNodeIdentifier* actualFavIdentifier = 
+        ActualFavoriteIdentifierL( aFavoriteNodeIdentifier );
+    DASSERT( actualFavIdentifier );
+    
+    if ( aDisclaimerOwner ) 
+        {
+        CNcdNodeIdentifier* disclaimerOwnerId =
+            CNcdNodeIdentifier::NewLC(
+                aDisclaimerOwner->Namespace(), aDisclaimerOwner->Id(),
+                aFavoriteNodeIdentifier.ClientUid() );
+                
+        RCatalogsBufferWriter writer;
+        writer.OpenLC();
+        actualFavIdentifier->ExternalizeL( writer() );
+        writer().WriteInt32L( ETrue );        
+        disclaimerOwnerId->ExternalizeL( writer() );
+
+        TInt output;
+                        
+        // Send the message to server side.
+        User::LeaveIfError(
+            ClientServerSession().SendSync(
+                NcdNodeFunctionIds::ENcdFavoriteManagerSetDisclaimer,
+                writer.PtrL(),
+                output,
+                Handle() ) );
+                
+        CleanupStack::PopAndDestroy( &writer );
+        CleanupStack::PopAndDestroy( disclaimerOwnerId );
+        }
+    else 
+        {
+        // NULL node was given, remove the disclaimer.
+
+        RCatalogsBufferWriter writer;
+        writer.OpenLC();
+        actualFavIdentifier->ExternalizeL( writer() );
+        writer().WriteInt32L( EFalse );        
+
+        TInt output;
+        
+        // Send the message to server side.
+        User::LeaveIfError(
+            ClientServerSession().SendSync(
+                NcdNodeFunctionIds::ENcdFavoriteManagerSetDisclaimer,
+                writer.PtrL(),
+                output,
+                Handle() ) );
+                
+        CleanupStack::PopAndDestroy( &writer );                
+        }
+    }
+    
+
+CNcdNodeDisclaimerProxy* CNcdFavoriteManagerProxy::NodeDisclaimerL(
+    const CNcdNodeIdentifier& aNodeIdentifier ) 
+    {
+    DLTRACEIN((""));
+    
+    // If the node is not favorite, leave
+    if ( !IsFavoriteL( aNodeIdentifier ) ) 
+        {
+        User::Leave( KErrArgument );
+        }
+        
+    CNcdNodeIdentifier* actualFavIdentifier =
+        ActualFavoriteIdentifierL( aNodeIdentifier );
+    DASSERT( actualFavIdentifier );
+        
+    // Get the disclaimer handle at first.
+    
+    RCatalogsBufferWriter writer;
+    writer.OpenLC();
+    actualFavIdentifier->ExternalizeL( writer() );
+    
+    TInt disclaimerHandle;
+    TInt handleError =
+        ClientServerSession().SendSync(
+            NcdNodeFunctionIds::ENcdFavoriteManagerDisclaimerHandle,
+            writer.PtrL(),
+            disclaimerHandle,
+            Handle() );
+            
+    CleanupStack::PopAndDestroy( &writer );
+    
+    if ( handleError == KErrNotFound ) 
+        {
+        // Disclaimer did not exist in server side, return NULL.
+        return NULL;
+        }
+    
+    User::LeaveIfError( handleError );
+    
+    CNcdNodeDisclaimerProxy* disclaimerProxy =
+        CNcdNodeDisclaimerProxy::NewL(
+            ClientServerSession(), disclaimerHandle, NULL );            
+        
+    return disclaimerProxy;
+    }
+    
+
+CNcdNodeProxy* CNcdFavoriteManagerProxy::FavoriteNodeByMetaDataL(
+    const CNcdNodeIdentifier& aMetaDataIdentifier ) const 
+    {
+    DLTRACEIN((""));
+    TInt count = iFavoriteNodes.Count();
+    for ( TInt i = 0; i < count; i++ ) 
+        {
+        CNcdNodeIdentifier* metaDataId = 
+            NcdNodeIdentifierEditor::CreateMetaDataIdentifierL( *iFavoriteNodes[ i ] );
+        if ( metaDataId->Equals( aMetaDataIdentifier ) )
+            {
+            delete metaDataId;
+            return &iNodeManager.NodeL( *iFavoriteNodes[ i ] );
+            }
+        delete metaDataId;
+        }
+        
+    // Node was not found, return NULL.
+    return NULL;
+    }
+            
+        
+        
+
+TInt CNcdFavoriteManagerProxy::FavoriteNodeCount() const
+    {
+    DLTRACEIN((""));
+    return iFavoriteNodes.Count();
+    }
+    
+
+MNcdNode* CNcdFavoriteManagerProxy::FavoriteNodeL( TInt aIndex ) const
+    {
+    DLTRACEIN((""));
+    
+    if ( aIndex < 0 || aIndex >= iFavoriteNodes.Count() ) 
+        {
+        User::Leave( KErrArgument );
+        }
+        
+    // The favorite list is in order where the previously added item is last.
+    // Return the nodes in the opposite order.
+    
+    TInt realIndex = iFavoriteNodes.Count() - 1 - aIndex;
+    CNcdNodeIdentifier* nodeId = iFavoriteNodes[ realIndex ];
+    MNcdNode* node = &iNodeManager.NodeL( *nodeId );
+    
+    // Increase the reference count by one.
+    node->AddRef();
+    
+    return node;
+    }
+    
+
+TInt CNcdFavoriteManagerProxy::FavoriteIndexL(
+    const TDesC& aNamespace, const TDesC& aId ) const 
+    {
+    DLTRACEIN((""));
+    
+    if ( iFavoriteNodes.Count() == 0 )
+        {
+        User::Leave( KErrNotFound );
+        }
+            
+    CNcdNodeIdentifier* nodeId = CNcdNodeIdentifier::NewLC(
+        aNamespace, aId, iFavoriteNodes[ 0 ]->ClientUid() );
+
+    // Get the actual favorite node identifier. It may be different, since
+    // there is only one node per metadata as favorite node.
+    // Note, the ownership of the returned object is not transferred.
+    CNcdNodeIdentifier* actualId = ActualFavoriteIdentifierL( *nodeId );
+    
+    if ( actualId == NULL ) 
+        {
+        User::Leave( KErrNotFound );
+        }
+
+    TInt index = NcdNodeIdentifierUtils::IdentifierIndex(
+        *actualId, iFavoriteNodes );
+    DASSERT( index != KErrNotFound );
+    
+    CleanupStack::PopAndDestroy( nodeId );
+    
+    // Since the list is in opposite order, the index must be converted.
+    TInt correctIndex = iFavoriteNodes.Count() - 1 - index;
+    DLINFO(("returning index: %d", correctIndex ));
+    return correctIndex;
+    }
+    
+
+void CNcdFavoriteManagerProxy::ClearFavoritesL() 
+    {
+    DLTRACEIN((""));
+    while ( iFavoriteNodes.Count() ) 
+        {
+        MNcdNode* node = FavoriteNodeL( 0 );
+        CleanupReleasePushL( *node );
+        
+        MNcdNodeFavorite* favorite = node->QueryInterfaceLC< MNcdNodeFavorite >();
+        DASSERT( favorite != NULL );
+        favorite->RemoveFromFavoritesL();
+        
+        CleanupStack::PopAndDestroy( favorite );
+        CleanupStack::PopAndDestroy( node );
+        }
+    }
+    
+        
+void CNcdFavoriteManagerProxy::ConstructL() 
+    {
+    DLTRACEIN((""));
+    
+    // Register the interface
+    MNcdFavoriteManager* interface( this );
+    AddInterfaceL(
+        CCatalogsInterfaceIdentifier::NewL( 
+            interface, this, MNcdFavoriteManager::KInterfaceUid ) );
+            
+    // Internalize the state from server side object
+    InternalizeL();
+    }
+    
+void CNcdFavoriteManagerProxy::InternalizeL() 
+    {
+    DLTRACEIN((""));
+    
+    HBufC8* data( NULL );
+    
+    // Internalize the node list from server side object
+    User::LeaveIfError(
+        ClientServerSession().SendSyncAlloc(
+            NcdNodeFunctionIds::ENcdInternalize,
+            KNullDesC8(),
+            data,
+            Handle(),
+            0 ) );
+        
+    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 );
+    }
+    
+void CNcdFavoriteManagerProxy::InternalizeDataL( RReadStream& aStream ) 
+    {
+    DLTRACEIN((""));
+    iFavoriteNodes.ResetAndDestroy();
+    
+    TInt identifierCount = aStream.ReadInt32L();
+    for ( TInt i = 0; i < identifierCount; i++ ) 
+        {
+        CNcdNodeIdentifier* nodeId = CNcdNodeIdentifier::NewLC( aStream );
+        iFavoriteNodes.AppendL( nodeId );
+        CleanupStack::Pop( nodeId );
+        }
+    }
+    
+CNcdNodeIdentifier* CNcdFavoriteManagerProxy::ActualFavoriteIdentifierL(
+    const CNcdNodeIdentifier& aNodeIdentifier ) const 
+    {
+    DLTRACEIN((""));
+    CNcdNodeIdentifier* metadataId =
+        NcdNodeIdentifierEditor::CreateMetaDataIdentifierLC( aNodeIdentifier );
+    CNcdNodeIdentifier* actualId = FavoriteIdentifierByMetaDataL( *metadataId );
+    CleanupStack::PopAndDestroy( metadataId );
+    return actualId;
+    }
+    
+CNcdNodeIdentifier* CNcdFavoriteManagerProxy::FavoriteIdentifierByMetaDataL(
+    const CNcdNodeIdentifier& aMetaDataIdentifier ) const 
+    {
+    DLTRACEIN((""));
+    TInt count = iFavoriteNodes.Count();
+    for ( TInt i = 0; i < count; i++ ) 
+        {
+        CNcdNodeIdentifier* metaId = NcdNodeIdentifierEditor::CreateMetaDataIdentifierL(
+            *iFavoriteNodes[ i ] );
+        if ( metaId->Equals( aMetaDataIdentifier ) ) 
+            {
+            delete metaId;
+            return iFavoriteNodes[ i ];
+            }
+        delete metaId;
+        }
+        
+    return NULL;
+    }
+