/*

* Copyright (c) 2008-2009 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:   Classes for thumbnail-related tasks.

*

*/

/**

 * @internal reviewed 31/07/2007 by Simon Brooks

 */

#include "glxtnthumbnailcreator.h"

#include "glxpanic.h"

#include "glxtnbackgroundgenerationtask.h"

#include "glxtncleanuptask.h"

#include "glxtndeletethumbnailstask.h"

#include "glxtnfileutility.h"

#include "glxtnfilteravailabletask.h"

#include "glxtngeneratethumbnailtask.h"

#include "glxtnquickthumbnailtask.h"

#include "glxtntaskmanager.h"

#include "glxtnthumbnailrequest.h"

#include "glxtnzoomedimagetask.h"

#include "mglxtnthumbnailcreatorclient.h"

#include <glxtracer.h>

#include <glxsettingsmodel.h>

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

// InstanceL

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

//

EXPORT_C CGlxtnThumbnailCreator* CGlxtnThumbnailCreator::InstanceL()

    {

    TRACER("CGlxtnThumbnailCreator::InstanceL()");

    CGlxtnThumbnailCreator* instance

                    = reinterpret_cast<CGlxtnThumbnailCreator*>(Dll::Tls());

    // Create instance if does not exist

    if ( !instance ) 

        {

    	instance = new (ELeave) CGlxtnThumbnailCreator();

    	CleanupStack::PushL(instance);

    	instance->ConstructL();

    	CleanupStack::Pop(instance);

        Dll::SetTls(instance);

        }

    // Add user	

    instance->iReferenceCount++;

    return instance;

    }

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

// Close

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

//

EXPORT_C void CGlxtnThumbnailCreator::Close(MGlxtnThumbnailStorage* aStorage)

    {

    TRACER("CGlxtnThumbnailCreator::Close()");

    // Cancel any tasks using the client's storage

    if ( aStorage )

        {

        iTaskManager->CancelTasks(aStorage);

        }

    __ASSERT_DEBUG(iReferenceCount > 0, Panic(EGlxPanicIllegalState));

    iReferenceCount--;

    if ( iReferenceCount < 1 )

        {

        Dll::SetTls(NULL);

        delete this;

        }

    }

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

// Constructor

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

//

CGlxtnThumbnailCreator::CGlxtnThumbnailCreator() 

	{

    TRACER("CGlxtnThumbnailCreator::CGlxtnThumbnailCreator()");

	}

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

// ConstructL

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

//

void CGlxtnThumbnailCreator::ConstructL() 

	{

    TRACER("CGlxtnThumbnailCreator::ConstructL()");

	iFileUtility = CGlxtnFileUtility::NewL();

	iTaskManager = CGlxtnTaskManager::NewL();

	iSettingsModel = CGlxSettingsModel::InstanceL();

	}

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

// Destructor

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

//

CGlxtnThumbnailCreator::~CGlxtnThumbnailCreator() 

	{

    TRACER("CGlxtnThumbnailCreator::~CGlxtnThumbnailCreator()");

	delete iTaskManager;

	delete iFileUtility;

	if (iSettingsModel)

	    {

	    iSettingsModel->Close();

	    }

	}

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

// FetchThumbnailL

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

//

EXPORT_C void CGlxtnThumbnailCreator::FetchThumbnailL(

                                    const TGlxThumbnailRequest& aRequestInfo,

                                    MGlxtnThumbnailCreatorClient& aClient) 

	{

    TRACER("void CGlxtnThumbnailCreator::FetchThumbnailL()");

	// Create the task

	CGlxtnTask* task = NULL;

    if ( 0 == aRequestInfo.iBitmapHandle )

        {

        task = CGlxtnBackgroundGenerationTask::NewL(aRequestInfo.iId,

                                                *iFileUtility, aClient, iSettingsModel->SupportedOrientations() );

        }

    else if ( ( 0 == aRequestInfo.iSizeClass.iWidth) || ( 0 == aRequestInfo.iSizeClass.iHeight ) )

        {

        User::Leave(KErrArgument);

        }

	else if ( !aRequestInfo.iCroppingRect.IsEmpty() )

	    {

	    task = CGlxtnZoomedImageTask::NewL(aRequestInfo,

	                                            *iFileUtility, aClient);

        }

	else if ( TGlxThumbnailRequest::EPrioritizeQuality == aRequestInfo.iPriorityMode )

		{

		task = CGlxtnGenerateThumbnailTask::NewL(aRequestInfo,

		                                        *iFileUtility, aClient);

		}

    else

        {

        task = CGlxtnQuickThumbnailTask::NewL(aRequestInfo,

                                                *iFileUtility, aClient);

        }

    iTaskManager->AddTaskL(task);   // Takes ownership

    } 

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

// DeleteThumbnailsL

// Starts deleting all stored thumbnails for a given item.  This will result

// in a callback to MGlxtnThumbnailCreatorClient::ThumbnailDeletionComplete().

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

//

EXPORT_C void CGlxtnThumbnailCreator::DeleteThumbnailsL(

            const TGlxMediaId& aItemId, MGlxtnThumbnailCreatorClient& aClient)

    {

    TRACER("void CGlxtnThumbnailCreator::DeleteThumbnailsL()");

    iTaskManager->AddTaskL(CGlxtnDeleteThumbnailsTask::NewL(aItemId, aClient));

    }

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

// FilterAvailableThumbnailsL

// Starts the filtering of items for which a thumbnail is available from a

// list of item IDs.  This will result in a callback to

// MGlxtnThumbnailCreatorClient::FilterAvailableComplete().

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

//

EXPORT_C void CGlxtnThumbnailCreator::FilterAvailableThumbnailsL(

                    const TArray<TGlxMediaId>& aItemArray, const TSize& aSize,

                    MGlxtnThumbnailCreatorClient& aClient)

    {

    TRACER("void CGlxtnThumbnailCreator::FilterAvailableThumbnailsL()");

    iTaskManager->AddTaskL(CGlxtnFilterAvailableTask::NewL(aItemArray, aSize,

                                                            aClient));

    }

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

// CleanupThumbnailsL

// Starts the cleanup of obsolete thumbnails from storage.  There is no

// callback indicating completion of the request.

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

//

EXPORT_C void CGlxtnThumbnailCreator::CleanupThumbnailsL(

                                        MGlxtnThumbnailStorage* aStorage)

    {

    TRACER("void CGlxtnThumbnailCreator::CleanupThumbnailsL()");

    iTaskManager->AddTaskL(CGlxtnCleanupTask::NewL(aStorage));

    }

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

// CancelRequest

// Cancel any ongoing tasks for a given item.  This ensures the TNC is not

// locking the media file.

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

//

EXPORT_C void CGlxtnThumbnailCreator::CancelRequest(const TGlxMediaId& aItemId)

    {

    TRACER("void CGlxtnThumbnailCreator::CancelRequest()");

    iTaskManager->CancelTasks(aItemId);

    }