/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:    Content update progress handling*
*/




// INCLUDE FILES
#include <centralrepository.h>
#include "CIptvUtil.h"
#include "CIptvTimer.h"
#include "IptvDebug.h"
#include "vcxnsupdateprogresshandler.h"
#include "vcxnsserviceprovider.h"
#include "vcxnsuiengine.h"

//CONSTANTS 
const TInt KVcxNsProgCompletedNoThumbnails = 10;
const TInt KVcxNsProgStartedNoThumbnails = 5;
const TInt KVcxNsProgStartedThumbnails = 3;
const TInt KVcxNsThumbProgressPercentVal = 3; 
const TInt KVcxNsProgressUpdateStarted = 5;
const TInt KVcxNsProgressUpdateCompletedNoThumb = 70;
const TInt KVcxNsProgressUpdateCompleted = 40;
const TInt KVcxNsProgressUpdateSucceeded = 99;
const TInt KVcxNsProgressTimerDefault = 200000;  // 0,2 sec

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

// -----------------------------------------------------------------------------
// CVcxNsUpdateProgressHandler::CVcxNsUpdateProgressHandler()
// -----------------------------------------------------------------------------
//
CVcxNsUpdateProgressHandler::CVcxNsUpdateProgressHandler( 
    CVcxNsUiEngine& aUiEngine ) 
:   iUiEngine( aUiEngine ),
    iThumbnails ( EFalse ),
    iPreviousProgress ( 0 ),
    iProgressPerThumbnail ( 0 ),
    iThumbnailsInPercent ( 0 )
    {
    }

// -----------------------------------------------------------------------------
// CVcxNsUpdateProgressHandler::NewL()
// -----------------------------------------------------------------------------
//
CVcxNsUpdateProgressHandler* CVcxNsUpdateProgressHandler::NewL( 
    CVcxNsUiEngine& aUiEngine )
    {
    IPTVLOGSTRING_HIGH_LEVEL(
        "UI Engine ## CVcxNsUpdateProgressHandler::NewL()");
    return new (ELeave) CVcxNsUpdateProgressHandler( aUiEngine );
    }

// -----------------------------------------------------------------------------
// CVcxNsUpdateProgressHandler::~CVcxNsUpdateProgressHandler()
// -----------------------------------------------------------------------------
//
CVcxNsUpdateProgressHandler::~CVcxNsUpdateProgressHandler()
    {
    if ( iProgressTimer && iProgressTimer->IsActive() )
        {
        iProgressTimer->Cancel();
        }
    
    delete iProgressTimer;
    }

// -----------------------------------------------------------------------------
// CVcxNsUpdateProgressHandler::RegisterObserver()
// -----------------------------------------------------------------------------
//
void CVcxNsUpdateProgressHandler::RegisterObserver(
    MVcxNsUpdateProgressObserver* aObserver )
    {
    IPTVLOGSTRING_HIGH_LEVEL(
        "UI Engine ## CVcxNsUpdateProgressHandler::RegisterObserver()");
    iProgressObserver = aObserver;
    }

// -----------------------------------------------------------------------------
// CVcxNsUpdateProgressHandler::DeRegisterObserver()
// -----------------------------------------------------------------------------
//
void CVcxNsUpdateProgressHandler::DeRegisterObserver(
    MVcxNsUpdateProgressObserver* aObserver )
    {
    IPTVLOGSTRING_HIGH_LEVEL(
        "UI Engine ## CVcxNsUpdateProgressHandler::DeRegisterObserver()");

    if ( aObserver == iProgressObserver )
        {
        iProgressObserver = NULL;
        }
    }

// -----------------------------------------------------------------------------
// CVcxNsUpdateProgressHandler::GetProgress
// -----------------------------------------------------------------------------
//
TInt CVcxNsUpdateProgressHandler::GetProgress( TUint32 aServiceId )
    {
    if ( aServiceId == iCurrentServiceId )
        {
        IPTVLOGSTRING2_HIGH_LEVEL(
            "UI Engine ## CVcxNsUpdateProgressHandler::GetProgress( %d )", 
            iPreviousProgress );
        return iPreviousProgress;
        }
   
    return KErrNotFound;
    }

// -----------------------------------------------------------------------------
// Handle service update status
// -----------------------------------------------------------------------------
//
void CVcxNsUpdateProgressHandler::HandleUpdateStatusChangeL( 
    TUint32 aServiceId,
    TInt aUpdateStatusMsg,
    TInt aInfo )
    {
    IPTVLOGSTRING_HIGH_LEVEL(
        "UI Engine ## CVcxNsUpdateProgressHandler::HandleUpdateStatusChangeL()");

    TInt progress( iPreviousProgress );
    iCurrentServiceId = aServiceId;
    iCurrentStatus = aUpdateStatusMsg; 
    
    if ( iProgressTimer && iProgressTimer->IsActive() )
        {
        iProgressTimer->Cancel();
        }
    
    switch ( aUpdateStatusMsg )
        {
        case KIptvVodUpdateStarted:
            {
            //Update started: progress 5% 
            progress = KVcxNsProgressUpdateStarted;
            TRAP_IGNORE( iThumbnails = ThumbnailsAllowedL() );
            StartProgressUpdateTimerL( );
            }
            break;
        case KIptvContentUpdateCompleted:
            {
            if ( iThumbnails )
                {
                //Update completed, thumbnails: progress 40%
                if ( progress < KVcxNsProgressUpdateCompleted )
                    {
                    progress = KVcxNsProgressUpdateCompleted;
                    }
                }
            else 
                {
                if ( progress < KVcxNsProgressUpdateCompletedNoThumb )
                    {
                    //Update completed, no thumbnails: progress 70%
                    progress = KVcxNsProgressUpdateCompletedNoThumb;
                    }
                StartProgressUpdateTimerL();
                }            
            }
            break;
        case KIptvThumbnailCount:
            {
            if ( aInfo > 0 && iThumbnails )
                {
                TInt thumbnailPercentage = 
                    ( KVcxNsProgressUpdateSucceeded - KVcxNsProgressUpdateCompleted ); 
                
                iProgressPerThumbnail = ( thumbnailPercentage / aInfo );
                
                //If there's more thumbnails than percents left:
                if ( iProgressPerThumbnail == 0 )
                    {
                    iThumbnailsInPercent = ( aInfo / thumbnailPercentage );
                    }
                }
            }
            break;
        case KIptvServiceThumbnailDownloaded:
        case KIptvContentThumbnailDownloaded:
            {
            if ( iProgressPerThumbnail > 0 )
                {
                progress += iProgressPerThumbnail;
                }
            else
                {
                iThumbnailCounter++;
                if ( iThumbnailCounter == 
                       ( iThumbnailsInPercent * KVcxNsThumbProgressPercentVal ) )
                    {
                    //When downloaded enough for increasing progress,
                    //zero thumbnail counter 
                    progress += KVcxNsThumbProgressPercentVal;
                    iThumbnailCounter = 0;
                    }
                }
            }
            break;
        case KIptvErrorEpgUpdateSuccessed:
            //Update succeeded: progress 99%
            progress = KVcxNsProgressUpdateSucceeded;
            break;
        
        case KIptvErrorEpgUpdateFailed:
        case KIptvErrorEpgUpdateStopped:    
            {
            progress = 0;
            iPreviousProgress = 0;
            iProgressPerThumbnail = 0;
            iThumbnailsInPercent = 0;
            iThumbnailCounter = 0;
            }
            break;
        default:
            break;
        }
    
    if ( progress > 0 && progress > iPreviousProgress )
        {
        //Refresh only if any progress
        RefreshProgressL( progress );
        }
    }

// --------------------------------------------------------------------------
// Timer expired
// --------------------------------------------------------------------------
//
void CVcxNsUpdateProgressHandler::TimerExpired( CIptvTimer* /*aTimer*/ )
    {
    TInt progress ( iPreviousProgress );
    TInt timeout ( KVcxNsProgressTimerDefault );
    
    if ( iThumbnails &&
            progress < KVcxNsProgressUpdateCompleted &&
            iCurrentStatus == KIptvVodUpdateStarted )
        {
        progress += KVcxNsProgStartedThumbnails; 
        }
    else if ( !iThumbnails && 
              progress < KVcxNsProgressUpdateCompletedNoThumb &&
              iCurrentStatus == KIptvVodUpdateStarted )
        {
        progress += KVcxNsProgStartedNoThumbnails;
        }
    else if ( !iThumbnails && 
              iCurrentStatus == KIptvContentUpdateCompleted )
        {
        progress += KVcxNsProgCompletedNoThumbnails;
        }
    
    if ( progress > iPreviousProgress )
        {
        TRAP_IGNORE( RefreshProgressL( progress ) );
        }

    if ( iProgressTimer )
        {
        if ( iProgressTimer ->IsActive() )
            {
            iProgressTimer->Cancel();
            }
        iProgressTimer->After( timeout );
        }
    }

// --------------------------------------------------------------------------
// Cancel progress handler timer
// --------------------------------------------------------------------------
//
void CVcxNsUpdateProgressHandler::Cancel()
    {
    if ( iProgressTimer && iProgressTimer->IsActive() )
        {
        IPTVLOGSTRING_HIGH_LEVEL(
            "UI Engine ## CVcxNsUpdateProgressHandler::Cancel()");
        iProgressTimer->Cancel();
        }
    }

// --------------------------------------------------------------------------
// Check if thumbnails are allowed
// --------------------------------------------------------------------------
//
TBool CVcxNsUpdateProgressHandler::ThumbnailsAllowedL() const
    {
    TBool thumbnails( EFalse );
    CRepository* cenRep = CRepository::NewL( KIptvCenRepUid );
    if ( cenRep )
        {
        TInt value;
        TInt error = cenRep->Get( KIptvCenRepVoDThumbnailsKey, value );
        if ( error == KErrNone && value == 1 )
            {
            thumbnails = ETrue;
            }
        }
    
    delete cenRep;
    return thumbnails;
    }

// --------------------------------------------------------------------------
// Check progress
// --------------------------------------------------------------------------
//
void CVcxNsUpdateProgressHandler::StartProgressUpdateTimerL( )
    {
    IPTVLOGSTRING_HIGH_LEVEL(
        "UI Engine ## CVcxNsUpdateProgressHandler::StartProgressUpdateTimerL()");
    
    if ( iProgressTimer && iProgressTimer->IsActive())
        {
        iProgressTimer->Cancel();
        }
    
    if ( !iProgressTimer )
        {
        iProgressTimer = CIptvTimer::NewL( CActive::EPriorityUserInput, *this );
        }

    iProgressTimer->After( KVcxNsProgressTimerDefault );
    }

// --------------------------------------------------------------------------
// Refresh progress
// --------------------------------------------------------------------------
//
void CVcxNsUpdateProgressHandler::RefreshProgressL( TInt aProgress )
    {
    IPTVLOGSTRING2_HIGH_LEVEL(
        "UI Engine ## CVcxNsUpdateProgressHandler::RefreshProgressL( %d )", 
        aProgress );

    if ( aProgress > KVcxNsProgressUpdateSucceeded )
        {
        aProgress = KVcxNsProgressUpdateSucceeded;
        }

    iPreviousProgress = aProgress;

    CVcxNsServiceProvider* serviceProvider = iUiEngine.ServiceProvider();
    if ( serviceProvider && aProgress > 0 )
        {
        TInt index = serviceProvider->ServiceIndex( iCurrentServiceId );
        if ( iProgressObserver )
            {
            iProgressObserver->HandleFeedUpdateProgressL( index, aProgress );
            }
        }
    }