/*
* 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:    Task used for thumbnail availability filter.
*
*/




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

#include "glxtnfilteravailabletask.h"

#include <glxassert.h>
#include <glxtracer.h>

#include "glxtnfileinfo.h"
#include "mglxtnstorage.h"
#include "mglxtnthumbnailcreatorclient.h"

// -----------------------------------------------------------------------------
// NewL
// -----------------------------------------------------------------------------
//
CGlxtnFilterAvailableTask* CGlxtnFilterAvailableTask::NewL(
                    const TArray<TGlxMediaId>& aItemArray, const TSize& aSize,
                    MGlxtnThumbnailCreatorClient& aClient)
    {
    TRACER("CGlxtnFilterAvailableTask* CGlxtnFilterAvailableTask::NewL()");
    CGlxtnFilterAvailableTask* task = new (ELeave) CGlxtnFilterAvailableTask(
                                                                aSize, aClient);
    CleanupStack::PushL(task);
    task->ConstructL(aItemArray);
    CleanupStack::Pop(task);
    return task;
    }

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
//
CGlxtnFilterAvailableTask::CGlxtnFilterAvailableTask(const TSize& aSize,
                                        MGlxtnThumbnailCreatorClient& aClient) :
    CGlxtnClientTask(KGlxtnTaskIdFilterAvailable, KGlxIdNone, aClient),
    iSize(aSize)
    {
    TRACER("CGlxtnFilterAvailableTask::CGlxtnFilterAvailableTask()");
    }

// -----------------------------------------------------------------------------
// ConstructL
// -----------------------------------------------------------------------------
//
void CGlxtnFilterAvailableTask::ConstructL(
                                        const TArray<TGlxMediaId>& aItemArray)
    {
    TRACER("void CGlxtnFilterAvailableTask::ConstructL()");
    TInt count = aItemArray.Count();
    for ( TInt i = 0; i < count; i++ )
        {
        iIdArray.AppendL(aItemArray[i]);
        }
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CGlxtnFilterAvailableTask::~CGlxtnFilterAvailableTask() 
    {
    TRACER("CGlxtnFilterAvailableTask::~CGlxtnFilterAvailableTask()");
    delete iFileInfo;
    iIdArray.Close();
    }

// -----------------------------------------------------------------------------
// DoStartL
// -----------------------------------------------------------------------------
//
TBool CGlxtnFilterAvailableTask::DoStartL(TRequestStatus& aStatus)
    {
    TRACER("TBool CGlxtnFilterAvailableTask::DoStartL()");
    iIndex = 0;

    GLX_ASSERT_DEBUG( !iFileInfo, Panic( EGlxPanicAlreadyInitialised ),
                        "iFileInfo not NULL" );
    iFileInfo = new (ELeave) CGlxtnFileInfo;

    return GetFileInfoL(aStatus);
    }

// -----------------------------------------------------------------------------
// DoCancel
// -----------------------------------------------------------------------------
//
void CGlxtnFilterAvailableTask::DoCancel() 
    {
    TRACER("void CGlxtnFilterAvailableTask::DoCancel()");
    Storage()->StorageCancel();
    }

// -----------------------------------------------------------------------------
// DoRunL
// -----------------------------------------------------------------------------
//
TBool CGlxtnFilterAvailableTask::DoRunL(TRequestStatus& aStatus) 
    {
    TRACER("TBool CGlxtnFilterAvailableTask::DoRunL()");
    TInt result = aStatus.Int();
    User::LeaveIfError(result);

    TBool active = EFalse;

    switch ( iState )
        {
        case EStateFetchingUri:
            Storage()->IsThumbnailAvailableL(iIdArray[iIndex], *iFileInfo,
                                                iSize, &aStatus);
            iState = EStateChecking;
            active = ETrue;
            break;

        case EStateChecking:
            if ( KGlxThumbnailNotAvailable == result )
                {
                iIndex++;
                }
            else
                {
                iIdArray.Remove(iIndex);
                }

            active = GetFileInfoL(aStatus);
            break;

        default:
            GLX_ASSERT_ALWAYS( EFalse, Panic( EGlxPanicIllegalState ),
                            "CGlxtnFilterAvailableTask: Illegal state" );
            break;
        }

    return active; 
    }

// -----------------------------------------------------------------------------
// DoRunError
// -----------------------------------------------------------------------------
//
TBool CGlxtnFilterAvailableTask::DoRunError(TInt aError)
    {
    TRACER("CGlxtnFilterAvailableTask::DoRunError()");
    Client().FilterAvailableComplete(iIdArray, aError);

    return EFalse;
    }

// -----------------------------------------------------------------------------
// GetFileInfoL
// -----------------------------------------------------------------------------
//
TBool CGlxtnFilterAvailableTask::GetFileInfoL(TRequestStatus& aStatus)
    {
    TRACER("CGlxtnFilterAvailableTask::GetFileInfoL()");
    if ( iIndex < iIdArray.Count() )
        {
        Client().FetchFileInfoL(iFileInfo, iIdArray[iIndex], &aStatus);
        iState = EStateFetchingUri;

        return ETrue;
        }

    // Finished checking the array
    Client().FilterAvailableComplete(iIdArray, KErrNone);

    return EFalse;
    }