/*

* 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:  Thumbnail server

 *

*/

#include <e32svr.h>

#include <MIHLScaler.h>

#include <driveinfo.h>

#include <caf/data.h>

#include <Oma2Agent.h>

#include <bautils.h>  

#include <mdesession.h>

#include "thumbnailserver.h"

#include "thumbnailtaskprocessor.h"

#include "thumbnailserversession.h"

#include "thumbnailmanagerconstants.h"

#include "thumbnailmanageruids.hrh"

#include "thumbnaillog.h"

#include "thumbnailstore.h"

#include "thumbnaildiskunmountobserver.h"

#include "thumbnailpanic.h"

#include "thumbnailcenrep.h"

#include "thumbnailmemorycardobserver.h"

#include "tmgetimei.h"

_LIT8( KThumbnailMimeWildCard, "*" );

_LIT8( KThumbnailMimeImage, "image" );

_LIT8( KThumbnailMimeVideo, "video" );

_LIT8( KThumbnailMimeAudio, "audio" );

const TChar KThumbnailMimeSeparatorChar = '/';

const TChar KThumbnailMimeWildCardChar = '*';

const TChar KThumbnailMimeTypeSeparatorChar = ' ';

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

// Server's policy here

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

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

// Total number of ranges

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

const TUint KThumbnailServerRangeCount = 16;

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

// Definition of the ranges

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

const TInt KThumbnailServerRanges[KThumbnailServerRangeCount] = 

{

    ERequestThumbByPathAsync,      

    ERequestThumbByFileHandleAsync,          

    EReleaseBitmap,

    ECancelRequest,

    EChangePriority,

    EDeleteThumbnails,

    EGetMimeTypeBufferSize,

    EGetMimeTypeList,

    ERequestThumbByIdAsync,

    ERequestThumbByBufferAsync,

    ERequestSetThumbnailByBuffer,

    EDeleteThumbnailsById,

    EUpdateThumbnails,

    ERequestSetThumbnailByBitmap,

    EThumbnailServerRequestCount,

};

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

// Policy to implement for each of the above ranges 

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

const TUint8 KThumbnailServerElementsIndex[KThumbnailServerRangeCount] = 

    {

    CPolicyServer::ECustomCheck,    // ERequestThumbByPathAsync

    CPolicyServer::ECustomCheck,    // ERequestThumbByFileHandleAsync

    CPolicyServer::ECustomCheck,    // EReleaseBitmap

    CPolicyServer::ECustomCheck,    // ECancelRequest

    CPolicyServer::ECustomCheck,    // EChangePriority

    CPolicyServer::ECustomCheck,    // EDeleteThumbnails

    CPolicyServer::ECustomCheck,    // EGetMimeTypeBufferSize

    CPolicyServer::ECustomCheck,    // EGetMimeTypeList

    CPolicyServer::ECustomCheck,    // ERequestThumbByIdAsync

    CPolicyServer::ECustomCheck,    // ERequestThumbByBufferAsync

    CPolicyServer::ECustomCheck,    // ERequestSetThumbnailByBuffer

    CPolicyServer::ECustomCheck,    // EDeleteThumbnailsById

    CPolicyServer::ECustomCheck,    // EUpdateThumbnails

    CPolicyServer::ECustomCheck,    // ERequestSetThumbnailByBitmap

    CPolicyServer::ECustomCheck,    // EThumbnailServerRequestCount

    };

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

// Package all the above together into a policy 

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

const CPolicyServer::TPolicy KThumbnailServerPolicy =

    {

    CPolicyServer::EAlwaysPass,

    KThumbnailServerRangeCount,      // number of ranges

    KThumbnailServerRanges,          // ranges array

    KThumbnailServerElementsIndex,   // elements<->ranges index

    NULL 

                               // array of elements

    };

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

// CustomSecurityCheckL

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

//

CPolicyServer::TCustomResult CThumbnailServer::CustomSecurityCheckL(

        const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/ )

    {

    CPolicyServer::TCustomResult securityCheckResult = EFail;

    switch ( aMsg.Function() )

        {

        case ERequestThumbByPathAsync:

        case ERequestThumbByFileHandleAsync:

        case ERequestThumbByIdAsync:

        case ERequestThumbByBufferAsync:

            {

            securityCheckResult = EPass;

            break;

            }

        case EReleaseBitmap:

        case ECancelRequest:

        case EChangePriority:

        case EDeleteThumbnails:

        case EGetMimeTypeBufferSize:

        case EGetMimeTypeList:

        case ERequestSetThumbnailByBuffer:

        case EDeleteThumbnailsById:

        case ERequestSetThumbnailByBitmap:

            {

            if( aMsg.HasCapability( ECapabilityReadDeviceData ) && 

                aMsg.HasCapability( ECapabilityWriteDeviceData ) )

                {

                securityCheckResult = EPass;

                }

            break;

            }

        case EThumbnailServerRequestCount:

        default:

            {

            securityCheckResult = EFail;

            }

        }

    return securityCheckResult;

    }

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

// CustomFailureActionL

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

//

CPolicyServer::TCustomResult CThumbnailServer::CustomFailureActionL(

        const RMessage2& /*aMsg*/, TInt /*aAction*/, const TSecurityInfo& /*aMissing*/ )

    {

    // Not used

    return EFail;

    }

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

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

// CThumbnailServer::CThumbnailServer()

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

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

//

CThumbnailServer::CThumbnailServer(): CPolicyServer( CActive::EPriorityStandard,

    KThumbnailServerPolicy, EUnsharableSessions )

    {

    // No implementation required

    }

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

// CThumbnailServer::NewL()

// Two-phased constructor.

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

//

CThumbnailServer* CThumbnailServer::NewL()

    {

    CThumbnailServer* self = new( ELeave )CThumbnailServer();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CThumbnailServer::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CThumbnailServer::ConstructL()

    {

    TN_DEBUG1( "CThumbnailServer::ConstructL()" );

#ifdef _DEBUG

    iPlaceholderCounter = 0;

#endif

    // create shutdown observer

    iShutdownObserver = CTMShutdownObserver::NewL( *this, KTMPSNotification, KShutdown, ETrue );  

    iShutdown = EFalse;

    // MDS session reconnect timer

    iReconnect = CPeriodic::NewL(CActive::EPriorityIdle);

    // connect to MDS

    iMdESession = CMdESession::NewL( *this );

    User::LeaveIfError( iFbsSession.Connect());

    User::LeaveIfError( Start( KThumbnailServerName ));

    User::LeaveIfError( iFs.Connect());

    iProcessor = CThumbnailTaskProcessor::NewL();

    REComSession::FinalClose();

    REComSession::ListImplementationsL( TUid::Uid( THUMBNAIL_PROVIDER_IF_UID ),

        iPluginInfoArray );

    CTMGetImei * imeiGetter = CTMGetImei::NewLC();

    iImei = imeiGetter->GetIMEI();

    CleanupStack::PopAndDestroy(imeiGetter);

    iFs.CreatePrivatePath(EDriveC);

    iFs.SetSessionToPrivate(EDriveC);

    iCenrep = CThumbnailCenRep::NewL();

    iPersistentSizes = iCenrep->GetPersistentSizes();

    iMMCObserver = CThumbnailMemoryCardObserver::NewL( this, iFs );

    iFormatObserver = CTMFormatObserver::NewL( *this );

    iFormatting = EFalse;

    //OpenStoresL();

    AddUnmountObserversL();

    }

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

// Destructor.

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

//

CThumbnailServer::~CThumbnailServer()

    {

    TN_DEBUG1( "CThumbnailServer::~CThumbnailServer()" );

    iShutdown = ETrue;

    delete iShutdownObserver;

    delete iProcessor;

    if(iReconnect)

        {

        iReconnect->Cancel();

        delete iReconnect;

        iReconnect = NULL;

        }

    if (iMdESession)

        {

        delete iMdESession;

        iMdESession = NULL;

        }

    ResetAndDestroyHashMap < TInt, CThumbnailStore > ( iStores );

    ResetAndDestroyHashMap < TInt32, CThumbnailProvider > ( iProviders );

    iUnmountObservers.ResetAndDestroy();

    delete iMMCObserver;

    delete iFormatObserver;

    THashMapIter < TInt, TThumbnailBitmapRef > bpiter( iBitmapPool );

    // const pointer to a non-const object

    const TThumbnailBitmapRef* ref = bpiter.NextValue();

    while ( ref )

        {

        delete ref->iBitmap;

        ref = bpiter.NextValue();

        }

    delete iScaler;

    iBitmapPool.Close();

    iFbsSession.Disconnect();

    iRecognizer.Close();

    iPluginInfoArray.ResetAndDestroy();

    delete iCenrep;

    iFs.Close();

    REComSession::FinalClose();

    }

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

// CThumbnailServer::HandleSessionOpened

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

//

void CThumbnailServer::HandleSessionOpened( CMdESession& /* aSession */, TInt /*aError*/ )

    {

    TN_DEBUG1( "CThumbnailServer::HandleSessionOpened");

    }

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

// CThumbnailServer::HandleSessionError

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

//

void CThumbnailServer::HandleSessionError( CMdESession& /*aSession*/, TInt aError )

    {

    TN_DEBUG2( "CThumbnailServer::HandleSessionError == %d", aError );

    if (aError != KErrNone && !iShutdown)

        {

        if (!iReconnect->IsActive())

            {

            iReconnect->Start( KMdEReconnect, KMdEReconnect, 

                               TCallBack(ReconnectCallBack, this));

            TN_DEBUG1( "CThumbnailServer::HandleSessionError() - reconnect timer started" );

            }

        } 

    }

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

// CThumbnailServer::NewSessionL()

// Creates new server session.

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

//

CSession2* CThumbnailServer::NewSessionL( const TVersion& aVersion, const

    RMessage2&  /*aMessage*/ )const

    {

    const TVersion v( KThumbnailServerMajorVersionNumber,

        KThumbnailServerMinorVersionNumber, KThumbnailServerBuildVersionNumber )

        ;

    if ( !User::QueryVersionSupported( v, aVersion ))

        {

        User::Leave( KErrNotSupported );

        }

    return new( ELeave )CThumbnailServerSession();

    }

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

// CThumbnailServer::ThreadFunctionL()

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

//

void CThumbnailServer::ThreadFunctionL()

    {

    // Rename own thread

    User::LeaveIfError( User::RenameThread( KThumbnailServerName ));

    CThumbnailServer* server = NULL;

    CActiveScheduler* scheduler = new( ELeave )CActiveScheduler();

    if ( scheduler )

        {

        CActiveScheduler::Install( scheduler );

        CleanupStack::PushL( scheduler );

        server = CThumbnailServer::NewL(); // Adds server in scheduler

        // No need to CleanupStack::PushL(server) since no leaves can happen

        RProcess::Rendezvous( KErrNone );

        TN_DEBUG1( 

            "CThumbnailServer::ThreadFunctionL() -- CActiveScheduler::Start() in" );

        CActiveScheduler::Start();

        TN_DEBUG1( 

            "CThumbnailServer::ThreadFunctionL() -- CActiveScheduler::Start() out" );

        // Comes here if server gets shut down

        delete server;

        CleanupStack::PopAndDestroy( scheduler );

        }

    }

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

// CThumbnailServer::AddSession()

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

//

void CThumbnailServer::AddSession()

    {

    TN_DEBUG2( "CThumbnailServer::AddSession() iSessionCount was %d",

        iSessionCount );

    iSessionCount++;

    }

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

// CThumbnailServer::DropSession()

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

//

void CThumbnailServer::DropSession(CThumbnailServerSession* aSession)

    {

    TN_DEBUG2( "CThumbnailServer::DropSession() iSessionCount was %d",

        iSessionCount );

    iSessionCount--;

    iProcessor->RemoveTasks(aSession);

    TN_DEBUG2( "CThumbnailServer::DropSession() aSession = 0x%08x", aSession );        

    // clean-up bitmap pool

    THashMapIter < TInt, TThumbnailBitmapRef > bpiter( iBitmapPool );

    // const pointer to a non-const object

    const TThumbnailBitmapRef* ref = bpiter.NextValue();

    while ( ref )

        {

        TN_DEBUG2( "CThumbnailServer::DropSession() - ref->iSession = 0x%08x", ref->iSession );

        if ( ref->iSession == aSession )

            {            

            delete ref->iBitmap;            

            bpiter.RemoveCurrent();

            TN_DEBUG2( "CThumbnailServer::DropSession() - deleted bitmap, left=%d", 

                                iBitmapPool.Count());

            }

        ref = bpiter.NextValue();

        }

    if ( iSessionCount <= 0 )

        {

        // rename thread

        User::RenameThread( KThumbnailServerShutdown );

        // server shutdown

        if (!iShutdown)

            {

            CActiveScheduler::Stop();

            iShutdown = ETrue;

            }

        }

    }

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

// CThumbnailServer::ShutdownNotification

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

//

void CThumbnailServer::ShutdownNotification()

    {

    if (!iShutdown)

        {

        CActiveScheduler::Stop();

        iShutdown = ETrue;

        }

    }

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

// CThumbnailServer::AddBitmapToPoolL()

// Add bitmap to bitmap pool.

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

//

void CThumbnailServer::AddBitmapToPoolL( CThumbnailServerSession* aSession,

    CFbsBitmap* aBitmap, TThumbnailServerRequestId aRequestId )

    {

    if( !aBitmap )

        {

        TN_DEBUG1( "CThumbnailServer::AddBitmapToPoolL() - KErrArgument");

        User::Leave( KErrArgument );

        }

    TN_DEBUG4( 

        "CThumbnailServer::AddBitmapToPoolL(aSession=0x%08x, aBitmap=0x%08x), handle=%d", aSession, aBitmap, aBitmap->Handle());

    TThumbnailBitmapRef* ptr = iBitmapPool.Find( aBitmap->Handle());

    TN_DEBUG2( "CThumbnailServer::AddBitmapToPoolL() - req id = %d", aRequestId.iRequestId );

    if ( ptr )

        {

        ptr->iRefCount++;

        }

    else

        {

        TThumbnailBitmapRef ref;

        ref.iBitmap = aBitmap;

        ref.iSession = aSession;

        ref.iRefCount = 1; // magic: first reference        

        ref.iRequestId = aRequestId.iRequestId;               

        iBitmapPool.InsertL( aBitmap->Handle(), ref );

        }

#ifdef _DEBUG

    TN_DEBUG2( "CThumbnailServer::BITMAP-POOL-COUNTER----------, Bitmaps = %d", iBitmapPool.Count() );

#endif

    }

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

// CThumbnailServer::StoreThumbnailL()

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

//

void CThumbnailServer::StoreThumbnailL( const TDesC& aPath, CFbsBitmap* aBitmap,

    const TSize& aOriginalSize, const TBool aCropped, const TThumbnailSize aThumbnailSize,

    const TInt64 aModified, const TBool aThumbFromPath, const TBool aCheckExist )

    {