/*

* Copyright (c) 2006-2007 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:  Server side session for Thumbnail Manager Server

 *

*/

#include <imageconversion.h> 

#include "thumbnailserversession.h"

#include "thumbnailserver.h"

#include "thumbnailtaskprocessor.h"

#include "thumbnailmanagerconstants.h"

#include "thumbnailgeneratetask.h"

#include "thumbnailscaletask.h"

#include "thumbnaildecodetask.h"

#ifdef RD_MDS_2_5

#include "thumbnailmdsquerytask.h"

#endif // RD_MDS_2_5

#include "thumbnaillog.h"

#include "thumbnailpanic.h"

#include "thumbnailcenrep.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CThumbnailServerSession::CThumbnailServerSession()

// C++ default constructor can NOT contain any code, that might leave.

// ---------------------------------------------------------------------------

//

CThumbnailServerSession::CThumbnailServerSession(): CSession2()

    {

    iBitmapHandle = 0;

    }

// ---------------------------------------------------------------------------

// CThumbnailServerSession::~CThumbnailServerSession()

// Destructor.

// ---------------------------------------------------------------------------

//

CThumbnailServerSession::~CThumbnailServerSession()

    {

    Server()->DropSession(this);

    }

// -----------------------------------------------------------------------------

// CThumbnailServerSession::DispatchMessageL()

// Message dispatcher.

// -----------------------------------------------------------------------------

//

TInt CThumbnailServerSession::DispatchMessageL( const RMessage2& aMessage )

    {

    TInt err( KErrNone );

    switch ( aMessage.Function())

        {

        case ERequestThumbByFileHandleAsync:

                {

                RequestThumbByFileHandleAsyncL( aMessage );

                break;

                }

        case ERequestThumbByPathAsync:

                {

                RequestThumbByPathAsyncL( aMessage );

                break;

                }

        case ERequestSetThumbnailByBuffer:

                {

                RequestSetThumbnailByBufferL( aMessage );

                break;

                }

        case ERequestSetThumbnailByBitmap:

                {

                RequestSetThumbnailByBitmapL( aMessage );

                break;

                }                

        case EReleaseBitmap:

                {

                ReleaseBitmap( aMessage );

                break;

                }

        case ECancelRequest:

                {

                err = CancelRequest( aMessage );

                break;

                }

        case EChangePriority:

                {

                err = ChangePriority( aMessage );

                break;

                }

        case ECreateThumbnails:

                {

                CreateThumbnailsL( aMessage );

                break;

                }

        case EDeleteThumbnails:

                {

                DeleteThumbnailsL( aMessage );

                break;

                }

        case EDeleteThumbnailsById:

                {

                DeleteThumbnailsByIdL( aMessage );

                break;

                }                

        case EGetMimeTypeBufferSize:

                {

                GetMimeTypeBufferSizeL( aMessage );

                break;

                }

        case EGetMimeTypeList:

                {

                GetMimeTypeListL( aMessage );

                break;

                }

        case ERequestThumbByIdAsync:

                {

                RequestThumbByIdAsyncL( aMessage );

                break;

                }

        case EUpdateThumbnails:

                {

                UpdateThumbnailsL( aMessage );

                break;

                }                  

        default:

                {

                err = KErrUnknown;

                break;

                }

        }

    return err;

    }

// ---------------------------------------------------------------------------

// CThumbnailServerSession::CreateL()

// ---------------------------------------------------------------------------

//

void CThumbnailServerSession::CreateL()

    {

    Server()->AddSession();

    }

// -----------------------------------------------------------------------------

// CThumbnailServerSession::ServiceL()

// Handles service request messages from clients.

// -----------------------------------------------------------------------------

//

void CThumbnailServerSession::ServiceL( const RMessage2& aMessage )

    {

    __ASSERT_DEBUG( !iMessage.Handle(), ThumbnailPanic(

        EThumbnailMessageNotCompleted ));

    if ( iMessage.Handle())

        {

        iMessage.Complete( KErrUnknown );

        iMessage = RMessage2();

        }

    iMessage = aMessage;

    // clean up possible trash

    if (iBitmapHandle)

        {

        Server()->DeleteBitmapFromPool( iBitmapHandle );

        iBitmapHandle = 0;

        }

    delete iBitmap;

    iBitmap = NULL;

    delete iBuffer;

    iBuffer = NULL;

    iOriginalSize = TSize();

    TInt ret = KErrNone;

    TRAPD( err, 

        {

        ret = DispatchMessageL( aMessage ); 

        }

     );

    if ( iMessage.Handle())

        {

        iMessage.Complete( ConvertSqlErrToE32Err( err != KErrNone ? err : ret ));

        iMessage = RMessage2();

        }

    else

    	{

    	return;

    	}

    }

// -----------------------------------------------------------------------------

// CThumbnailServerSession::Server()

// Returns the server pointer.

// -----------------------------------------------------------------------------

//

CThumbnailServer* CThumbnailServerSession::Server()

    {

    return ( CThumbnailServer* )( CSession2::Server());

    }

// -----------------------------------------------------------------------------

// CThumbnailServerSession::Cancel()

// -----------------------------------------------------------------------------

//

void CThumbnailServerSession::Cancel()

    {

    }

// -----------------------------------------------------------------------------

// CThumbnailServerSession::UpdateThumbnailsL()

// -----------------------------------------------------------------------------

//

void CThumbnailServerSession::UpdateThumbnailsL( const RMessage2& aMessage )

    {

    TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL()" );

    if(aMessage.Int1() != KCheckValue)

       {

       TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - error in aMessage - leaving" );

       User::Leave(KErrArgument);

       }

    // read message params

    aMessage.ReadL( 0, iRequestParams );

    const TThumbnailRequestParams& params = iRequestParams();

    TBool finished = Server()->UpdateThumbnailsL( params.iThumbnailId, params.iFileName, params.iOrientation, params.iModified );

    if (finished)

        {

        TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - finished" );

        aMessage.Complete( KErrNone );

        }

    else

        {

        TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - need to recreate thumbs" );

        // need to create new thumbs

        aMessage.Complete( KThumbnailErrThumbnailNotFound );

        }

    iMessage = RMessage2();

    }

// -----------------------------------------------------------------------------

// CThumbnailServerSession::RequestThumbByIdAsyncL()

// -----------------------------------------------------------------------------

//

void CThumbnailServerSession::RequestThumbByIdAsyncL( const RMessage2&

    aMessage )

    {

#ifdef _DEBUG

    TTime aStart, aStop;

    aStart.UniversalTime();

#endif

    TN_DEBUG1( "CThumbnailServerSession::RequestThumbByIdAsyncL() - begin" );

    if(aMessage.Int1() != KCheckValue)

       {

       TN_DEBUG1( "CThumbnailServerSession::RequestThumbByIdAsync() - error in aMessage - leaving" );

       User::Leave(KErrArgument);

       }

    aMessage.ReadL( 0, iRequestParams );

    const TThumbnailRequestParams& params = iRequestParams();

    TRAPD( err, Server()->FetchThumbnailL( params.iThumbnailId, iBitmap, iBuffer,

                                           params.iThumbnailSize, iOriginalSize ));

    if ( !err && iBitmap )

        {

        TN_DEBUG1( 

            "CThumbnailServerSession::RequestThumbByIdAsyncL() - found existing thumbnail- bitmap" );

        ProcessBitmapL();

        }

    else if ( !err && iBuffer)

        {

        TN_DEBUG1( 

             "CThumbnailServerSession::RequestThumbByIdAsyncL() - found existing thumbnail- jpeg" );

        CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()

                 ->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );

        CleanupStack::PushL( task );

        task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage );

        Server()->QueueTaskL( task );

        CleanupStack::Pop( task ); // owned by processor now

        // Decode task is now responsible for completing the message

        iMessage = RMessage2();

        //CThumbnailDecodeTask is responsible freeing

        iBuffer = NULL;

        }

    else if( err == KErrCompletion )                

        {

        // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion

        TN_DEBUG1( 

            "CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail blacklisted" );

        aMessage.Complete( err );

        iMessage = RMessage2();

        }

    else                

        {

        TN_DEBUG2( 

            "CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail not found ( query path from MDS ), err=%d ", err );

#ifdef RD_MDS_2_5        

        // try to query path from MDS

        CThumbnailMDSQueryTask* task = new( ELeave )CThumbnailMDSQueryTask(

                Server()->Processor(), params.iPriority + 1, Server()->GetMdESession(), *Server());

        CleanupStack::PushL( task );

        task->QueryPathByIdL(params.iThumbnailId);

        task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage );

        Server()->QueueTaskL( task );

        CleanupStack::Pop( task ); // owned by processor now

        // query task is now responsible for completing the message

        iMessage = RMessage2();

#else

        User::Leave(KThumbnailErrThumbnailNotFound);

#endif // RD_MDS_2_5

        }   

#ifdef _DEBUG

    aStop.UniversalTime();

    TN_DEBUG2( "CThumbnailStore::RequestThumbByIdAsyncL() request took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000 );

#endif 

    TN_DEBUG1("CThumbnailServerSession::RequestThumbByIdAsyncL() - end" );

    }

// -----------------------------------------------------------------------------

// CThumbnailServerSession::RequestThumbByFileHandleAsync()

// -----------------------------------------------------------------------------

//

void CThumbnailServerSession::RequestThumbByFileHandleAsyncL( const RMessage2&

    aMessage )

    {

    TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL()" );

    if(aMessage.Int1() != KCheckValue)

       {

       TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsync() - error in aMessage - leaving" );

       User::Leave(KErrArgument);

       }

    aMessage.ReadL( 0, iRequestParams );

    const TThumbnailRequestParams& params = iRequestParams();

    RFile64 file;

    User::LeaveIfError( file.AdoptFromClient( aMessage, 2, 3 ));

    ResolveMimeTypeL(&file);

    if(params.iThumbnailSize == EFullScreenThumbnailSize ||

       params.iThumbnailSize == EGridThumbnailSize ||

       params.iThumbnailSize == EListThumbnailSize )

        {

        TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

        sourceType = Server()->SourceTypeFromMimeType( params.iMimeType );

        ModifyThumbnailSize(sourceType);

        }

    // CreateThumbnails

    if (params.iControlFlags == EThumbnailGeneratePersistentSizesOnly)

        {

        CleanupClosePushL( file );

        CreateGenerateTaskFromFileHandleL( &file );

        CleanupStack::Pop( &file );         

        }

    // single thumbnail request

    else

        {

        TRAPD( err, FetchThumbnailL());

        if ( !err && iBitmap )

            {

            TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - bitmap " );

            // Thumbnail already stored

            file.Close();

            TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed");

            ProcessBitmapL();

            }

        else if ( (err == KErrNotFound || err == KErrAccessDenied) && 

                 !(params.iFlags& CThumbnailManager::EDoNotCreate) )

            {

            CreateGenerateTaskFromFileHandleL( &file);

            }

        else if (!err && iBuffer)

            {

            TN_DEBUG1( 

                "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - jpeg " );

            CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()

                        ->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );

            CleanupStack::PushL( task );

            task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage );

            Server()->QueueTaskL( task );

            CleanupStack::Pop( task ); // owned by processor now

            // Decode task is now responsible for completing the message

            iMessage = RMessage2();

            //CThumbnailDecodeTask is responsible freeing

            iBuffer = NULL;

            file.Close();

            TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed");

            }

        else

            {

            TN_DEBUG2( 

                "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - thumbnail not found, err=%d", err );

            aMessage.Complete( ConvertSqlErrToE32Err( err ));

            iMessage = RMessage2();

            }     

        }

    }

// -----------------------------------------------------------------------------

// CThumbnailServerSession::RequestThumbByPathAsync()

// -----------------------------------------------------------------------------

//

void CThumbnailServerSession::RequestThumbByPathAsyncL( const RMessage2&

    aMessage )

    {

    TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsyncL()" );

#ifdef _DEBUG

    TTime aStart, aStop;

    aStart.UniversalTime();

#endif

    if(aMessage.Int1() != KCheckValue)

       {

       TN_DEBUG1( "CThumbnailServerSession::RequestThumbByPathAsync() - error in aMessage - leaving" );

       User::Leave(KErrArgument);

       }

    aMessage.ReadL( 0, iRequestParams );

    const TThumbnailRequestParams& params = iRequestParams();

    ResolveMimeTypeL(NULL);

    if(params.iThumbnailSize == EFullScreenThumbnailSize ||

       params.iThumbnailSize == EGridThumbnailSize ||

       params.iThumbnailSize == EListThumbnailSize )

        {

        TInt sourceType = TThumbnailPersistentSize::EUnknownSourceType;

        sourceType = Server()->SourceTypeFromMimeType( params.iMimeType );

        ModifyThumbnailSize(sourceType);

        }

    // should always be true

    if (params.iControlFlags != EThumbnailGeneratePersistentSizesOnly)

		{

	    TRAPD( err, FetchThumbnailL());

	    if ( !err && iBitmap )

	        {

	        TN_DEBUG1( 

	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - found existing thumbnail- bitmap" );

	        ProcessBitmapL();

	        }

	    else if ( !err && iBuffer)

	        {

	        TN_DEBUG1( 

	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - found existing thumbnail- jpeg" );

	        CThumbnailDecodeTask* task = new( ELeave )CThumbnailDecodeTask( Server()

	               ->Processor(), * Server(), iBuffer, params.iPriority, params.iDisplayMode );

	        CleanupStack::PushL( task );

	        task->SetMessageData( TThumbnailServerRequestId( this, params.iRequestId ), iMessage );

	        Server()->QueueTaskL( task );

	        CleanupStack::Pop( task ); // owned by processor now

	        // Decode task is now responsible for completing the message

	        iMessage = RMessage2();

	        //CThumbnailDecodeTask is responsible freeing

	        iBuffer = NULL;

	        }

	    else if( err == KErrCompletion )

	        {

            // If thumbnail of requested size is blacklisted, fetching is left with KErrCompletion

            TN_DEBUG1( 

                "CThumbnailServerSession::RequestThumbByIdAsyncL() - thumbnail blacklisted" );

            aMessage.Complete( err );

            iMessage = RMessage2();

	        }

	    else 

	        {

	        TN_DEBUG2( 

	            "CThumbnailServerSession::RequestThumbByPathAsyncL() - thumbnail not found, err = %d", err );

	        if ( (err == KErrNotFound || err == KErrAccessDenied) && 

	            !(params.iFlags& CThumbnailManager::EDoNotCreate) )

	            {

	            // Special error code so that the client side can open the file

	            // and retry the request using file handle

	            err = KThumbnailErrThumbnailNotFound;