/*

* 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 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 )

    {

    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;

    if ( iMessage.Handle())

        {

        iMessage = RMessage2();

        }

    }

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

// 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.iFileName, params.iOrientation, params.iModified );

    RArray < TThumbnailPersistentSize >* missingSizes = NULL;

    TBool gridSizeOnly(EFalse);

    if ( params.iQualityPreference == CThumbnailManager

                    ::EOptimizeForQualityWithPreview )

        {

        gridSizeOnly = ETrue;

        }

    if (finished)

        {

        // source type

        TDataType mimeType;

        TInt sourceType = 0;

        TInt err = Server()->MimeTypeFromFileExt( params.iFileName, mimeType );

        // get missing sizes

        if ( err == KErrNone && ( params.iControlFlags & EThumbnailGeneratePersistentSizesOnly ) != 0 )

            {

            sourceType = Server()->SourceTypeFromMimeType( mimeType );

            missingSizes = new (ELeave) RArray < TThumbnailPersistentSize >;

            CleanupClosePushL( *missingSizes );

            Server()->GetMissingSizesL( params.iFileName, sourceType, *missingSizes, gridSizeOnly );

            if ( missingSizes->Count() == 0)

                {

                // all thumbs already exist

                CleanupStack::PopAndDestroy( missingSizes );

                delete missingSizes;

                missingSizes = NULL;

                }            

            }

        if(!missingSizes)

            {

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

            aMessage.Complete( KErrNone );

            }

        else

            {

            TN_DEBUG1( "CThumbnailServerSession::UpdateThumbnailsL() - some sizes missing..." ); 

            }

        }

    if (missingSizes || !finished)

        {

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

        if(missingSizes)

            {

            CleanupStack::PopAndDestroy( missingSizes );

            delete missingSizes;

            missingSizes = NULL;

            }

        if(Server()->StoreForPathL(params.iFileName)->IsDiskFull())

            {

            User::Leave( KErrDiskFull );

            }

        // need to create new thumbs

        aMessage.Complete( KThumbnailErrThumbnailNotFound );

        }

    else

        {

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

        }

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

#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, EFalse);

        Server()->QueueTaskL( task );

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

        // query task is now responsible for completing the message

        iMessage = RMessage2();

#else

        User::Leave(KErrNotSupported);

#endif // RD_MDS_2_5

#ifdef _DEBUG

    aStop.UniversalTime();

    TN_DEBUG2( "CThumbnailServerSession::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)

        {

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

        CleanupClosePushL( file );

        CreateGenerateTaskFromFileHandleL( &file );

        CleanupStack::Pop( &file );         

        }

    // single thumbnail request

    else

        {

        TRAPD( err, FetchThumbnailL());

        if( err == KErrCompletion )

            {

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

            TN_DEBUG1( 

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

            aMessage.Complete( err );

            iMessage = RMessage2();

            }

        else 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) )

            {

            TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - KErrNotFound & !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 );

            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 )

        {