/*

* 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:  Engine to fetch the logos 

*

*/

#include <aknnotewrappers.h> 

#include "irlogodownloadengine.h"

#include "irnetworkcontroller.h"

#include "ircachemgmt.h"

#include "irhttprequestdata.h"

#include "irdebug.h"

#include "irdataproviderconstants.h"

#include "iractivenetworkobserver.h"

_LIT(KLogoX, "?x=");

_LIT(KLogoY, "&y=");

const TInt KPresetsArrayMaxLength = 50;

const TInt KLogoSize = 59;

const TInt KParameterSize = 12;

const TInt KTen = 10;

const TInt KCacheAvailable = 4;

const TInt KLogo = 4;

const TInt KStatusOK = 200;

const TInt KStatusMultipleChoices = 300;

const TInt KStatusNotModified = 304;

const TInt KStatusGatewayTimeout = 504;

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

// CIRLogoDownloadEngine::NewL()

// Creates instance of CIRLogoDownloadEngine.

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

//

EXPORT_C CIRLogoDownloadEngine* CIRLogoDownloadEngine::NewL()

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::NewL - Entering" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    IRLOG_DEBUG( "CIRLogoDownloadEngine::NewL - Exiting" );

    return self;

    }

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

// CIRLogoDownloadEngine::CIRLogoDownloadEngine()

// Standard C++ constructor

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

//

CIRLogoDownloadEngine::CIRLogoDownloadEngine()

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::CIRLogoDownloadEngine " );

    //code here, if needed

    }

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

// CIRLogoDownloadEngine::~CIRLogoDownloadEngine()

// Destructs instance of CIRLogoDownloadEngine.

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

//

EXPORT_C CIRLogoDownloadEngine::~CIRLogoDownloadEngine()

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::~CIRLogoDownloadEngine - Entering" );

    if ( iReqBody )

        {

        delete iReqBody;

        iReqBody = NULL;

        }

    if ( iRespBody )

        {

        delete iRespBody;

        iRespBody = NULL;

        }

    CancelTransaction();

    // remove E32USER-CBase-66

#ifdef _DEBUG

    TRAP_IGNORE( iLogoSession.Close() );

#else

    iLogoSession.Close();

#endif

    if ( iCopyPreset )

        {

        delete iCopyPreset;

        }

    if ( iCacheTempPreset )

        {

        delete iCacheTempPreset;

        }

    if ( iTempPreset )

        {

        delete iTempPreset;

        }

    if ( iPresetArray )

        {

        iPresetArray->ResetAndDestroy();

        }

    delete iPresetArray;

    if ( iObserverArray )

        {

        delete iObserverArray;

        iObserverArray = NULL;

        }

    if ( iReqFromArray )

        {

        delete iReqFromArray;

        iReqFromArray = NULL;

        }

    if ( iCachePresetArray )

        {

        iCachePresetArray->ResetAndDestroy();

        }

    delete iCachePresetArray;

    if ( iCacheObserverArray )

        {

        delete iCacheObserverArray;

        iCacheObserverArray = NULL;

        }

    if ( iCacheReqFromArray )

        {

        delete iCacheReqFromArray;

        iCacheReqFromArray = NULL;

        }

    if ( iIRNetworkControllerHandle )

        {

        iIRNetworkControllerHandle->DeleteActiveNetworkObserver( *this );

        iIRNetworkControllerHandle->Close();

        }

    if ( iCache )

        {

        iCache->RemoveObserver( this );

        iCache->Close();

        }

    if ( iResponseHeaders )

        {

        delete iResponseHeaders;

        }

    IRLOG_DEBUG( "CIRLogoDownloadEngine::~CIRLogoDownloadEngine - Exiting" );

    }

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

// CIRLogoDownloadEngine::ConstructL()

// 2nd phase construction

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

//

void CIRLogoDownloadEngine::ConstructL()

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::ConstructL - Entering" );

    iPresetArray = new( ELeave ) CArrayPtrFlat<CIRIsdsPreset>(

                                                     KPresetsArrayMaxLength );

    iObserverArray = new( ELeave ) CArrayPtrFlat<MLogoDownloadObserver>(

                                                     KPresetsArrayMaxLength );

    iReqFromArray = new( ELeave ) CArrayFixFlat<TInt>(

                                                     KPresetsArrayMaxLength );

    iCachePresetArray = new( ELeave ) CArrayPtrFlat<CIRIsdsPreset>(

                                                     KPresetsArrayMaxLength );

    iCacheObserverArray = new( ELeave ) CArrayPtrFlat<MLogoDownloadObserver>( 

                                                     KPresetsArrayMaxLength );

    iCacheReqFromArray = new( ELeave ) CArrayFixFlat<TInt>(

                                                     KPresetsArrayMaxLength );

    iPresetArrayPos = 0;

    iReqFromArrayPos = 0;

    iObserverArrayPos = 0;

    iCachePresetArrayPos = 0;

    iCacheReqFromArrayPos = 0;

    iCacheObserverArrayPos = 0;

    iImageIndex = 0; //using temporarily till the isds provides urls

    iPresetModifiedStatus = EFalse;

    iFirstTime = ETrue;

    iIRNetworkControllerHandle = CIRNetworkController::OpenL();

    iIRNetworkControllerHandle->RegisterActiveNetworkObserverL( *this );

    iCache = CIRCacheMgmt::OpenL( *this );

    iCache->AddObserverL( this );

    iResponseHeaders = new ( ELeave ) CIRHttpResponseData;

    //change to use the new session for logo downloading

    TRAPD( LeaveValue, iLogoSession.OpenL() );

    if ( LeaveValue != KErrNone )

        {

        // Most common error; no access point configured, and session creation

        // leaves with KErrNotFound.

        // Load a string from the resource file and add the error code to string

        User::Leave( LeaveValue );

        }

    IRLOG_DEBUG( "CIRLogoDownloadEngine::ConstructL - Exiting" );

    }

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

// CIRLogoDownloadEngine::IsRunning()

// To know the status of downloading logo

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

//

EXPORT_C TBool CIRLogoDownloadEngine::IsRunning() const

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::IsRunning" );

    return iRunning;

    }

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

// CIRLogoDownloadEngine::SetHeaderL()

// to set the headers of the http transaction

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

//

void CIRLogoDownloadEngine::SetHeaderL( RHTTPHeaders aHeaders,

                               TInt aHdrField, const TDesC8& aHdrValue ) const

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::SetHeaderL - Entering" );

    RStringF valStr = iLogoSession.StringPool().OpenFStringL( aHdrValue );

    CleanupClosePushL( valStr );

    THTTPHdrVal val( valStr );

    aHeaders.SetFieldL( iLogoSession.StringPool().StringF( aHdrField,

                                            RHTTPSession::GetTable() ), val );

    CleanupStack::PopAndDestroy( &valStr ); // valStr

    IRLOG_DEBUG( "CIRLogoDownloadEngine::SetHeaderL - Exiting" );

    }

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

// CIRLogoDownloadEngine::SendRequestL()

// API is called from the SearchResultsView for to download logo 

// while doing Add to Favorites

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

//

EXPORT_C void CIRLogoDownloadEngine::SendRequestL( CIRIsdsPreset* aPreset,

                                                  TInt aXValue, TInt aYValue )

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::SendRequestL - Entering" );

    if ( !iCheckingCache )

        {

        ++iImageIndex;

        iCheckingCache = ETrue;

        iCacheReqFrom = 0;

        if ( iCacheTempPreset )

            {

            delete iCacheTempPreset;

            }

        iCacheTempPreset = NULL;

        iCacheTempPreset = CIRIsdsPreset::NewL();

        *iCacheTempPreset = *aPreset;

        if ( iCacheTempPreset->GetImgUrl().Length() != 0 )

            {

            if ( ( aXValue > 0 ) && ( aYValue > 0 ) )

                {

                //Append the parameters(width,height) of the logo size to imgUrl

                TInt size = iCacheTempPreset->GetImgUrl().Length()

                                + KParameterSize;

                RBuf urlWithSize;

                CleanupClosePushL(urlWithSize);

                urlWithSize.CreateL( size );

                urlWithSize.Copy( iCacheTempPreset->GetImgUrl() );

                urlWithSize.Append( KLogoX );

                urlWithSize.AppendNum( aXValue );

                urlWithSize.Append( KLogoY );

                urlWithSize.AppendNum( aYValue );

                //set the imgUrl with parameters to the preset

                iCacheTempPreset->SetImgUrlL( urlWithSize );

                CleanupStack::PopAndDestroy();

                }

            //This method checks whether the logo is available

            // for the request made

            iForceGet = EFalse;

            CheckCacheForLogoL( 0 );

            }

        else

            {

            //imgUrl doesnt exist in the Preset

            iCheckingCache = EFalse;

            return;

            }

        iCheckingCache = EFalse;

        if ( !iLogoCached )

            {

            FetchLogoDataL( iCacheTempPreset );

            }

        }

    else

        {

        CIRIsdsPreset* tempPreset;

        tempPreset = CIRIsdsPreset::NewL();

        CleanupStack::PushL(tempPreset);

        *tempPreset = *aPreset;

        if ( tempPreset->GetImgUrl().Length() != 0 )

            {

            if ( ( aXValue > 0 ) && ( aYValue > 0 ) )

                {

                //Append the parameters(width,height) of the logo size to imgUrl

                TInt size = tempPreset->GetImgUrl().Length() + KParameterSize;

                RBuf urlWithSize;

                CleanupClosePushL(urlWithSize);

                urlWithSize.CreateL( size );

                urlWithSize.Copy( tempPreset->GetImgUrl() );

                urlWithSize.Append( KLogoX );

                urlWithSize.AppendNum( aXValue );

                urlWithSize.Append( KLogoY );

                urlWithSize.AppendNum( aYValue );

                //set the imgUrl with parameters to the preset

                tempPreset->SetImgUrlL( urlWithSize );

                CleanupStack::PopAndDestroy();

                }

            }

        iCachePresetArray->AppendL( tempPreset );

        iCacheReqFromArray->AppendL( 0 );

        CleanupStack::PopAndDestroy();

        }

    IRLOG_DEBUG( "CIRLogoDownloadEngine::SendRequestL - Exiting" );

    }

EXPORT_C TBool CIRLogoDownloadEngine::IsLogoCachedL( 

                          CIRIsdsPreset* aPreset, TInt aXValue, TInt aYValue )

{

    TInt cached = 0;

    if(iCacheTempPreset)

    {

        delete iCacheTempPreset;

        iCacheTempPreset = NULL;

    }

    iCacheTempPreset = CIRIsdsPreset::NewL();

    *iCacheTempPreset = *aPreset;

    iCacheReqMade = EFalse;

    if (iCacheTempPreset->GetImgUrl().Length() != 0)

    {

        if ((aXValue > 0) && (aYValue > 0))

        {

            //Append the parameters(width,height) of the logo size to imgUrl

            TInt size = iCacheTempPreset->GetImgUrl().Length() + KParameterSize;

            RBuf urlWithSize;

            CleanupClosePushL(urlWithSize);

            urlWithSize.CreateL(size);

            urlWithSize.Copy(iCacheTempPreset->GetImgUrl());

            urlWithSize.Append(KLogoX);

            urlWithSize.AppendNum(aXValue);

            urlWithSize.Append(KLogoY);

            urlWithSize.AppendNum(aYValue);

            //set the imgUrl with parameters to the preset

            iCacheTempPreset->SetImgUrlL(urlWithSize);

            CleanupStack::PopAndDestroy();

        }

    }

    iCache->CheckCacheL(KLogo,iCacheTempPreset->GetImgUrl(),EFalse,cached);

    return (CIRCacheMgmt::ECacheUseable == cached)?ETrue:EFalse;     

}

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

// CIRLogoDownloadEngine::SendRequestL()

// API is called from several views for to download logo 

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

//

EXPORT_C void CIRLogoDownloadEngine::SendRequestL( CIRIsdsPreset* aPreset,

                                    MLogoDownloadObserver* aLogoHandle, 

                                    TInt aNPVReq, TInt aXValue, TInt aYValue )

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::SendRequestL - Entering" );

    if ( aPreset->GetChannelType() == 0 )

        {

        aLogoHandle->PresetLogoDownloadedL( aPreset );

        }

    else if ( !iCheckingCache )

        {

        ++iImageIndex;

        iCheckingCache = ETrue;

        if ( aNPVReq == 2 )

            {

            iCacheReqFrom = 2;

            }

        else

            {

            iCacheReqFrom = 1;

            }

        if ( iCacheTempPreset )

            {

            delete iCacheTempPreset;

            iCacheTempPreset = NULL;

            }

        iCacheTempPreset = CIRIsdsPreset::NewL();

        *iCacheTempPreset = *aPreset;

        iCacheTempLogoHandle = aLogoHandle;

        if ( iCacheTempPreset->GetImgUrl().Length() != 0 )

            {

            if ( ( aXValue > 0 ) && ( aYValue > 0 ) )

                {

                //Append the parameters(width,height) of the logo size to imgUrl

                TInt size = iCacheTempPreset->GetImgUrl().Length()

                                + KParameterSize;

                RBuf urlWithSize;

                CleanupClosePushL(urlWithSize);

                urlWithSize.CreateL( size );

                urlWithSize.Copy( iCacheTempPreset->GetImgUrl() );

                urlWithSize.Append( KLogoX );

                urlWithSize.AppendNum( aXValue );

                urlWithSize.Append( KLogoY );

                urlWithSize.AppendNum( aYValue );

                //set the imgUrl with parameters to the preset

                iCacheTempPreset->SetImgUrlL( urlWithSize );

                CleanupStack::PopAndDestroy();

                }

            if ( iCacheReqFrom == 1 || iCacheReqFrom == 2 )

                {

                //This method checks whether the logo is available

                // for the request made

                iForceGet = EFalse;

                CheckCacheForLogoL( 0 );

                }

/*            else if(iCacheReqFrom==2)

                {

                //the request has come from NowPlayingView(NPV)

                //dont check for logo availability in cache

                //download the logo freshly

                iLogoCached=EFalse;                                

                }

*/            }

        else

            {

            //imgUrl doesnt exist in the Preset

            iCheckingCache = EFalse;

            return;

            }

        iCheckingCache = EFalse;

        if ( !iLogoCached )

            {

            FetchLogoDataL( iCacheTempPreset, aLogoHandle, iCacheReqFrom );

            }

        }

    else

        {

        CIRIsdsPreset* tempPreset;

        tempPreset = CIRIsdsPreset::NewL();

        CleanupStack::PushL(tempPreset);

        *tempPreset = *aPreset;

        if ( tempPreset->GetImgUrl().Length() != 0 )

            {

            if ( ( aXValue > 0 ) && ( aYValue > 0 ) )

                {

                //Append the parameters(width,height) of the logo size to imgUrl

                TInt size = tempPreset->GetImgUrl().Length() + KParameterSize;

                RBuf urlWithSize;

                CleanupClosePushL(urlWithSize);

                urlWithSize.CreateL( size );

                urlWithSize.Copy( tempPreset->GetImgUrl() );

                urlWithSize.Append( KLogoX );

                urlWithSize.AppendNum( aXValue );

                urlWithSize.Append( KLogoY );

                urlWithSize.AppendNum( aYValue );

                //set the imgUrl with parameters to the preset

                tempPreset->SetImgUrlL( urlWithSize );

                CleanupStack::PopAndDestroy();

                }

            }

        iCachePresetArray->AppendL( tempPreset );

        iCacheObserverArray->AppendL( aLogoHandle );

        if ( aNPVReq == 2 )

            {

            iCacheReqFromArray->AppendL( 2 );

            }

        else

            {

            iCacheReqFromArray->AppendL( 1 );

            }

        CleanupStack::PopAndDestroy();

        }

    IRLOG_DEBUG( "CIRLogoDownloadEngine::SendRequestL - Exiting" );

    }

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

// CIRLogoDownloadEngine::GetCacheLogoL()

// takes the url as a parameter and returns the logo data which is in cache

// this API is called form the search results for to display logo on the view

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

//

EXPORT_C void CIRLogoDownloadEngine::GetCacheLogoL( const TDesC& aUrl,

                                                               TInt& aStatus )

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::GetCacheLogoL - Entering" );

    iSendingLogo = 2;

    iResult = 0;

    iForceGet = EFalse;

    //2 means, this API is called for the search results view

    iCacheReqMade = ETrue;

    iCache->CheckCacheL( KLogo, aUrl, iForceGet, iResult );

    aStatus = iResult;

    IRLOG_DEBUG( "CIRLogoDownloadEngine::GetCacheLogoL - Exiting" );

    }

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

// CIRLogoDownloadEngine::SendCacheLogo()

// sends the logo which is cached

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

//

EXPORT_C TDesC8& CIRLogoDownloadEngine::SendCacheLogo()

    {

    IRLOG_DEBUG( "CIRLogoDownloadEngine::SendCacheLogo" );

    return iCache->iLogoData;

    }

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

// CIRLogoDownloadEngine::FetchLogoDataL()

// API is used to download logo from isds/internet

// called in the API SendRequestL(CIRIsdsPreset* aPreset)