/*

* 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<CNcdKeyValuePair>&

    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<CNcdKeyValuePair> 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()