/*

* Copyright (c) 2002 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 loading implementation.

*

*/

// INCLUDE FILES

#include    "CPhCntThumbnailLoaderImpl.h"

#include    "MPhoneCntPbkOwner.h"

#include    "MPhCntThumbnailLoaderObserver.h"

#include    "cphcntcontactid.h"

#include    "cphcntpbkcontactid.h"

#include    "cphcntpbkthumbnailloader.h"

#include    <CPbkContactItem.h>

#include    <CPbkContactEngine.h>

#include    <CPbkThumbnailManager.h>

#include    <fbs.h>

// CONSTANTS

// Granularity of thumbnail array.

const TInt KPhoneThumbnailArrayGranularity = 5;

// Maximum amount of thumbnails.

const TInt KPhoneThumbnailMax = 20;

// Panic literal for thumbnail related panics.

_LIT( KPhCntThumbnailLoaderPanic, "PhCntThumb" );

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

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

// CPhCntThumbnailLoaderImpl::NewL

// Two-phased constructor.

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

//

CPhCntThumbnailLoaderImpl* CPhCntThumbnailLoaderImpl::NewL(

        MPhCntThumbnailLoaderObserver& aObserver,

        MPhoneCntPbkOwner& aPbkOwner,

        MPhCntThumbnailLoader& aLoader )

    {

    CPhCntThumbnailLoaderImpl* self = 

        new ( ELeave ) CPhCntThumbnailLoaderImpl( 

            aObserver,

            aPbkOwner,

            aLoader );

    CleanupStack::PushL( self );

    self->ConstructL( aPbkOwner );

    CleanupStack::Pop();

    return self;

    }

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

// CPhCntThumbnailLoaderImpl::~CPhCntThumbnailLoaderImpl

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

//

CPhCntThumbnailLoaderImpl::~CPhCntThumbnailLoaderImpl()

    {

    delete iBitmap;

    ClearThumbnailArray();

    iArray.Close();

    delete iLoader;

    delete iBridge;

    }

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

// CPhCntThumbnailLoaderImpl::Load

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

//

TInt CPhCntThumbnailLoaderImpl::Load( 

        TThumbnailId& aId, 

        const CPhCntContactId& aContactId )

    {

    // If condition doesn't hold, then definitely something is badly

    // wrong.

    if ( iArray.Count() < KPhoneThumbnailMax )

        {

        TRAPD( err, AttemptLoadL( aId, aContactId ) );

        if ( err != KErrNone )

            {

            aId = KPhCntThumbnailNullId;

            }

        return err;

        }

    else

        {

        aId = KPhCntThumbnailNullId;

        return KErrNotFound;

        }

    }

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

// CPhCntThumbnailLoaderImpl::Cancel

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

//

void CPhCntThumbnailLoaderImpl::Cancel( 

        TThumbnailId aId )

    {

    TInt index = FindById( aId );

    // If not found, then we can ignore the call.

    if ( index == KErrNotFound )

        {

        return;

        }

    // Remove thumbnail loading information from array.

    RemoveThumbnailArrayEntry( index );

    // If we are currently loading this, then cancel loading.

    if ( iCurrent != KPhCntThumbnailNullId && aId == iCurrent )

        {      

        CancelLoad();

        }

    if ( iCurrent == KPhCntThumbnailNullId && iArray.Count() )

        {

        Start( ELoadFromContact );

        }

    }

void CPhCntThumbnailLoaderImpl::LoadingCompleted(

    CFbsBitmap* aBitmap,

    TInt aResult )

    {

    if( aResult == KErrNone )

        {

        if ( iCurrent != KPhCntThumbnailNullId )

            {

            iBitmap = aBitmap;

            Start( EProcessResult );       

            }

        else

            {

            delete aBitmap;

            }

        }

    else

        {

        if ( iCurrent != KPhCntThumbnailNullId )

            {

            TThumbnailId old = iCurrent;

            Cancel( old );

            Notify( old, aResult, NULL );

            }

        }

    }

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

// CPhCntThumbnailLoaderImpl::CPhCntThumbnailLoaderImpl

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CPhCntThumbnailLoaderImpl::CPhCntThumbnailLoaderImpl(

        MPhCntThumbnailLoaderObserver& aObserver,

        MPhoneCntPbkOwner& /*aPbkOwner*/,

        MPhCntThumbnailLoader& aLoader )

    : iObserver( aObserver ),

      iArray( KPhoneThumbnailArrayGranularity ),

      iCurrent( KPhCntThumbnailNullId ),

      iLoader( &aLoader )

    {

    }

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

// CPhCntThumbnailLoaderImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPhCntThumbnailLoaderImpl::ConstructL(

    MPhoneCntPbkOwner& /*aPbkOwner*/ )

    {

    iBridge = 

        CIdle::NewL(

            CActive::EPriorityStandard );

    }

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

// CPhCntThumbnailLoaderImpl::AttemptLoadL

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

//

void CPhCntThumbnailLoaderImpl::AttemptLoadL( 

        TThumbnailId aId,

        const CPhCntContactId& aContactId )

    {

    // Create new thumbnail information.

    TThumbnailInfo info;

    info.iId = aId;

    info.iContactId = aContactId.CloneL();

    User::LeaveIfError( iArray.Append( info ) );

    // If there were no items, then we can start loading the first image.

    if ( iCurrent == KPhCntThumbnailNullId )

        {

        Start( ELoadFromContact );

        }

    }

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

// CPhCntThumbnailLoaderImpl::StartLoadL

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

//

void CPhCntThumbnailLoaderImpl::StartLoadL()

    {

    if ( !iArray.Count() )

        {

        return;

        }

    TThumbnailInfo& info = iArray[ 0 ]; // first

    iCurrent = info.iId;

    // Clear pbk

    ClearPbk( ETrue ); 

    iLoader->LoadL( *info.iContactId, *this );

    }

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

// CPhCntThumbnailLoaderImpl::CancelLoad

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

//

void CPhCntThumbnailLoaderImpl::CancelLoad()

    {

    iCurrent = KPhCntThumbnailNullId; 

    delete iBitmap;

    iBitmap = NULL;

    ClearPbk( iArray.Count() );

    }

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

// CPhCntThumbnailLoaderImpl::ProcessResultL

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

//

void CPhCntThumbnailLoaderImpl::ProcessResultL()

    {

    if ( iCurrent == KPhCntThumbnailNullId )

        {

        return;

        }

    if ( !iBitmap )

        {

        User::Leave( KErrNotFound );

        }

    else

        {

        CFbsBitmap* bitmap = iBitmap;

        iBitmap = NULL;

        TThumbnailId old = iCurrent;

        Cancel( iCurrent );

        Notify( old, KErrNone, bitmap );

        }

    }

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

// CPhCntThumbnailLoaderImpl::HandleStartL

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

//

void CPhCntThumbnailLoaderImpl::HandleStartL()

    {

    switch ( iState )

        {

        case ELoadFromContact:

            StartLoadL();

            break;

        case EProcessResult:

            ProcessResultL();

            break;

        default:

            Panic( EPanicInvalidState );

            break;

        }

    }

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

// CPhCntThumbnailLoaderImpl::HandleStart

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

//

void CPhCntThumbnailLoaderImpl::HandleStart()

    {

    TRAPD( err, HandleStartL() );

    if ( err != KErrNone && iCurrent != KPhCntThumbnailNullId )

        {

        TThumbnailId old = iCurrent;

        Cancel( iCurrent );

        Notify( old, err, NULL );

        }

    }

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

// CPhCntThumbnailLoaderImpl::Start

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

//

void CPhCntThumbnailLoaderImpl::Start( TState aState )

    {

    iState = aState;

    iBridge->Cancel();

    iBridge->Start( TCallBack( DoStart, this ) );

    }

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

// CPhCntThumbnailLoaderImpl::DoStart

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

//

TInt CPhCntThumbnailLoaderImpl::DoStart( TAny* aAny )

    {

    CPhCntThumbnailLoaderImpl* loader =

        static_cast< CPhCntThumbnailLoaderImpl* >( aAny );

    loader->HandleStart();

    return KErrNone;

    }

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

// CPhCntThumbnailLoaderImpl::Notify

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

//

void CPhCntThumbnailLoaderImpl::Notify( 

        TThumbnailId aId,

        TInt aResult, 

        CFbsBitmap* aBitmap )

    {

    iObserver.MpctloThumbnailLoaded( aId, aResult, aBitmap );

    }

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

// CPhCntThumbnailLoaderImpl::ClearPbk

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

//

void CPhCntThumbnailLoaderImpl::ClearPbk( TBool aMore )

    {

    iLoader->Cancel();

    if ( !aMore )

        {

        iLoader->Release();

        }

    }

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

// CPhCntThumbnailLoaderImpl::FindById

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

//

TInt CPhCntThumbnailLoaderImpl::FindById( TThumbnailId aId )

    {

    TThumbnailInfo info;

    info.iId = aId;

    // info.iContactId doesn't matter.

    return 

        iArray.Find( 

            info,

            TIdentityRelation<TThumbnailInfo>( CompareIds ) );

    }

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

// CPhCntThumbnailLoaderImpl::CompareIds

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

//

TBool CPhCntThumbnailLoaderImpl::CompareIds( 

        const TThumbnailInfo& aFirst,

        const TThumbnailInfo& aSecond )

    {

    return aFirst.iId == aSecond.iId;

    }

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

// CPhCntThumbnailLoaderImpl::Panic

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

//

void CPhCntThumbnailLoaderImpl::Panic( 

        TPanicReason aReason )

    {

    User::Panic( KPhCntThumbnailLoaderPanic, aReason );

    }

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

// CPhCntThumbnailLoaderImpl::ClearThumbnailArray

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

//   

void CPhCntThumbnailLoaderImpl::ClearThumbnailArray()

    {

    const TInt count( iArray.Count() );

    for( TInt i = 0; i < count; i++ ) 

        {

        RemoveThumbnailArrayEntry( i );

        }

    }

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

// CPhCntThumbnailLoaderImpl::ClearThumbnailArrayEntry

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

//        

void CPhCntThumbnailLoaderImpl::RemoveThumbnailArrayEntry( TInt aIndex )

    {

    TThumbnailInfo info = iArray[aIndex];

    delete info.iContactId;

    iArray.Remove( aIndex );

    }

//  End of File