diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/client/src/ncdnodepreviewproxy.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ncdengine/provider/client/src/ncdnodepreviewproxy.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,334 @@
+/*
+* 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 CNcdNodePreviewProxy class implementation
+*
+*/
+
+
+#include <f32file.h>
+#include "ncdnodepreviewproxy.h"
+#include "ncdnodemetadataproxy.h"
+#include "ncdnodeproxy.h"
+#include "ncdoperationimpl.h"
+#include "ncddownloadoperationproxy.h"
+#include "ncdoperationmanagerproxy.h"
+#include "catalogsclientserver.h"
+#include "ncdnodeidentifier.h"
+#include "ncdnodefunctionids.h"
+#include "ncdnodeclassids.h"
+#include "catalogsinterfaceidentifier.h"
+#include "catalogsutils.h"
+#include "catalogsdebug.h"
+#include "ncdpanics.h"
+#include "ncderrors.h"
+
+
+// ======== PUBLIC MEMBER FUNCTIONS ========
+
+CNcdNodePreviewProxy::CNcdNodePreviewProxy(
+    MCatalogsClientServer& aSession,
+    TInt aHandle,
+    CNcdNodeMetadataProxy& aMetadata )
+: CNcdInterfaceBaseProxy( aSession, aHandle, &aMetadata ),
+  iMetadata( aMetadata )
+    {
+    }
+
+
+void CNcdNodePreviewProxy::ConstructL()
+    {
+    // Register the interface
+    MNcdNodePreview* interface( this );
+    AddInterfaceL( 
+        CCatalogsInterfaceIdentifier::NewL( interface, this, MNcdNodePreview::KInterfaceUid ) );
+    
+    // Let this leave if internalization fails.
+    InternalizeL();
+    }
+
+
+CNcdNodePreviewProxy* CNcdNodePreviewProxy::NewL(
+    MCatalogsClientServer& aSession,
+    TInt aHandle,
+    CNcdNodeMetadataProxy& aMetadata )
+    {
+    CNcdNodePreviewProxy* self = 
+        CNcdNodePreviewProxy::NewLC( aSession, aHandle, aMetadata );
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+CNcdNodePreviewProxy* CNcdNodePreviewProxy::NewLC(
+    MCatalogsClientServer& aSession,
+    TInt aHandle,
+    CNcdNodeMetadataProxy& aMetadata )
+    {
+    CNcdNodePreviewProxy* self = 
+        new( ELeave ) CNcdNodePreviewProxy( aSession, aHandle, aMetadata );
+    // Using PushL because the object does not have any references yet
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    return self;
+    }
+
+
+CNcdNodePreviewProxy::~CNcdNodePreviewProxy()
+    {
+    // 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( MNcdNodePreview::KInterfaceUid );
+    
+    
+    // Delete member variables here
+    // Do not delete node and operation manager because
+    // this object does not own them.
+    iPreviewMimeTypes.ResetAndDestroy();
+    }
+
+
+CNcdNodeMetadataProxy& CNcdNodePreviewProxy::MetadataL() const
+    {
+    DLTRACEIN((""));
+
+   if( IsObsolete() )
+        {
+        DLERROR(("Preview is obsolete. Metadata may not exist."));
+        User::Leave( KNcdErrorObsolete );
+        }
+    
+    DLTRACEOUT((""));
+    
+    return iMetadata;
+    }
+
+
+void CNcdNodePreviewProxy::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(("Preview was obsolete"));
+        SetObsolete( ETrue );
+        // 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( MNcdNodePreview::KInterfaceUid );
+        // Remove from the parent
+        RemoveFromParent();
+        // Now update the interface for this object just in case somebody needs it.
+        // Register the interface
+        MNcdNodePreview* interface( this );
+        AddInterfaceL( 
+            CCatalogsInterfaceIdentifier::NewL( interface, this, MNcdNodePreview::KInterfaceUid ) );
+        }
+    else
+        {
+        // Just in case it was some times obsolete but not anymore
+        SetObsolete( EFalse );
+        }
+
+    // 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((""));    
+    }
+
+
+TBool CNcdNodePreviewProxy::IsObsolete() const
+    {
+    return iObsolete;
+    }
+
+void CNcdNodePreviewProxy::SetObsolete( TBool aObsolete )
+    {
+    iObsolete = aObsolete;
+    }    
+    
+
+void CNcdNodePreviewProxy::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::ENcdNodePreviewClassId )
+        {
+        // classId is not recognized
+        DLERROR(("Class id was not recognized!"));
+        // For testing purposes assert here
+        DASSERT( EFalse );
+        
+        // Otherwise leave is adequate
+        User::Leave( KErrCorrupt );
+        }
+
+
+    iPreviewCount = aStream.ReadInt16L();
+    
+    iPreviewMimeTypes.ResetAndDestroy();
+    HBufC* previewMimeType = NULL;
+    
+    for( int i = 0; i < iPreviewCount; i++ )
+        {
+        InternalizeDesL( previewMimeType, aStream );
+        CleanupStack::PushL( previewMimeType );
+        iPreviewMimeTypes.Append( previewMimeType );
+        CleanupStack::Pop( previewMimeType );
+        previewMimeType = NULL;
+        }
+
+    DLTRACEOUT((""));
+    }
+
+TInt CNcdNodePreviewProxy::PreviewCount() const
+    {
+    return iPreviewCount;
+    }
+
+TBool CNcdNodePreviewProxy::IsPreviewLoadedL( TInt aIndex ) const
+    {
+    NCD_ASSERT_ALWAYS( 
+        aIndex >= 0 && aIndex < PreviewCount(),
+        ENcdPanicIndexOutOfRange );
+    
+    HBufC8* filenumber = IntToDes8LC( aIndex );
+    TInt isLoaded;
+    
+    User::LeaveIfError(
+        ClientServerSession().
+            SendSync( NcdNodeFunctionIds::ENcdIsPreviewLoaded,
+                      *filenumber,
+                      isLoaded,
+                      Handle()));
+    CleanupStack::PopAndDestroy( filenumber );
+    return isLoaded;
+    }
+
+const TDesC& CNcdNodePreviewProxy::PreviewMimeType( TInt aIndex ) const
+    {
+    NCD_ASSERT_ALWAYS( 
+        aIndex >= 0 && aIndex < PreviewCount(),
+        ENcdPanicIndexOutOfRange );
+    
+    return *iPreviewMimeTypes[aIndex];
+    }
+
+MNcdDownloadOperation* CNcdNodePreviewProxy::LoadPreviewL( TInt aIndex,
+                                                           MNcdDownloadOperationObserver* aObserver )
+    {
+    DLTRACEIN((""));
+    
+    NCD_ASSERT_ALWAYS( 
+        aIndex >= 0 && aIndex < PreviewCount(),
+        ENcdPanicIndexOutOfRange );
+
+    CNcdDownloadOperationProxy* download =
+        MetadataL().Node().OperationManager().
+        CreateDownloadOperationL(
+            ENcdPreviewDownload,
+            MetadataL().Node(),
+            KNullDesC,
+            aObserver,
+            aIndex );
+    
+    iOperationObserver = aObserver;
+    DLTRACEOUT((""));
+    return download;
+
+    }
+
+RFile CNcdNodePreviewProxy::PreviewFileL( TInt aIndex ) const
+    {
+    DLTRACEIN(( "aIndex: %i", aIndex ));
+
+    NCD_ASSERT_ALWAYS( 
+        aIndex >= 0 && aIndex < PreviewCount(),
+        ENcdPanicIndexOutOfRange );
+    
+    // Convert index to a descriptor
+    HBufC8* filenumber = IntToDes8LC( aIndex );
+    
+    /**
+     * Add error handling, is it okay to leave here?
+     */
+    RFile fileHandle = ClientServerSession().SendSyncFileOpenL( 
+        NcdNodeFunctionIds::ENcdPreviewOpenFile,
+        *filenumber,        
+        Handle());
+    
+    CleanupStack::PopAndDestroy( filenumber );
+    
+    DLTRACEOUT((""));
+    return fileHandle;
+    }
+
+void CNcdNodePreviewProxy::DownloadProgress( MNcdDownloadOperation& /*aOperation*/,
+    TNcdProgress /*aProgress*/ )
+    {
+    }
+    
+void CNcdNodePreviewProxy::QueryReceived( MNcdDownloadOperation& /*aOperation*/,
+    MNcdQuery* /*aQuery*/ )
+    {
+    }
+
+void CNcdNodePreviewProxy::OperationComplete( MNcdDownloadOperation& /*aOperation*/,
+    TInt /*aError*/ )
+    {
+    DLTRACEIN((""));
+    DLTRACEOUT((""));
+    }
+