/*
* Copyright (c) 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:      CUpnpProgressWatcher class implementation
 *
*/







//  Include Files
#include <e32property.h>
#include <e32debug.h>
#include <upnpstring.h>
#include "upnpprogresswatcher.h"
#include "upnpfilesharingengine.h"

_LIT( KComponentLogfile, "applicationengine.txt");
#include "upnplog.h"


// CONSTANTS
// The maximum numbers of sharingrequests that can be currently received
const TInt KMaxSharingReqs = 2;

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

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::CUpnpProgressWatcher
// C++ default constructor can NOT contain any code, that
// might leave.
// --------------------------------------------------------------------------
//
CUpnpProgressWatcher::CUpnpProgressWatcher( CUPnPFileSharingEngine& aEngine )
    : CActive(CActive::EPriorityStandard),
      iEngine( aEngine )
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::CUpnpProgressWatcher");
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::NewL
// Two-phased constructor.
// --------------------------------------------------------------------------
//
CUpnpProgressWatcher* CUpnpProgressWatcher::NewL( 
    CUPnPFileSharingEngine& aEngine )
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::NewL");
    CUpnpProgressWatcher* self = 
        new ( ELeave ) CUpnpProgressWatcher( aEngine );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::ConstructL
// Symbian 2nd phase constructor can leave.
// --------------------------------------------------------------------------
//
void CUpnpProgressWatcher::ConstructL()
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::ConstructL");

    User::LeaveIfError( 
        iProgressInfo.Attach( KUpnpContentServerCat, ESharingProgress ) );
    CActiveScheduler::Add(this);
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::~CUpnpProgressWatcher
// Destructor
// --------------------------------------------------------------------------
//
CUpnpProgressWatcher::~CUpnpProgressWatcher()
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::~CUpnpProgressWatcher");

    Cancel();
    iProgressInfo.Close();
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::StartL
// Starts active object
// --------------------------------------------------------------------------
//
void CUpnpProgressWatcher::StartL()
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::StartL begin");

    TUpnpProgress totalProgress;
    TPckgBuf<TUpnpProgress> progressBuf( totalProgress );
    TInt pubErr = iProgressInfo.Get( progressBuf );
    iEngine.SetShareFileComplete( EFalse );
    if ( !pubErr )
        {
        Mem::Copy( &totalProgress, 
                   progressBuf.Ptr(), sizeof( TUpnpProgress ) );

        // update UI
        SetShowCompleteNote( totalProgress );
        TProgressInfos progressArr( KMaxSharingReqs );
        progressArr.Append( totalProgress.iImageVideoProgress );
        progressArr.Append( totalProgress.iMusicProgress );
        CleanupClosePushL( progressArr );
        if ( iEngine.Observer() )
            {
            iEngine.Observer()->HandleSharingProgress( 
                iEngine, progressArr );
            }
        CleanupStack::PopAndDestroy( &progressArr );
        }

    if ( !IsActive() && SharingOngoing( totalProgress ) )
        {
        // start periodical reporting of progress
        RunL();
        }

    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::StartL end");
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::Stop
// Stops active object
// --------------------------------------------------------------------------
//
void CUpnpProgressWatcher::Stop()
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::Stop");
    Cancel();
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::RunL
// Called when asyncronous request is ready
// --------------------------------------------------------------------------
//
void CUpnpProgressWatcher::RunL()
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::RunL");

    // resubscribe before processing new value to prevent missing updates
    iProgressInfo.Subscribe( iStatus );
    SetActive();

    TUpnpProgress totalProgress;
    TPckgBuf< TUpnpProgress > paramspkg( totalProgress );


    // get value
    if ( iProgressInfo.Get(
             KUpnpContentServerCat, 
             ESharingProgress, 
             paramspkg ) == KErrNotFound )
        {
        // property deleted, do necessary actions here...
        }
    else
        {
        Mem::Copy( &totalProgress, paramspkg.Ptr(), sizeof( TUpnpProgress ) );


        TProgressInfos progressArr( KMaxSharingReqs );

        progressArr.Append( totalProgress.iImageVideoProgress );
        progressArr.Append( totalProgress.iMusicProgress );

        CleanupClosePushL( progressArr );
        if ( totalProgress.iError )
            {
            HandleErrorL( totalProgress );
            }
        else
            {
            if ( iEngine.Observer() )
                {
                // update UI
                iEngine.Observer()->HandleSharingProgress( 
                    iEngine, progressArr );
                }
            if ( progressArr.Count() )
                {
                __LOG2( "ProgressCallbackL: cout:%d progress:%d\n",
                    progressArr.Count(), 
                    progressArr[0].iProgress );
                }
            else
                {
                __LOG( "progressArr empty" );
                }

            SetShowCompleteNote( totalProgress );

            if ( iShowCompleteNote && !SharingOngoing( totalProgress ) )
                {
                // no sharing operations ongoing, stop query
                Cancel();
                // inform UI to show final note
                if ( iEngine.Observer() && iShowCompleteNote )
                    {
                    iShowCompleteNote = EFalse;
                    iEngine.Observer()->HandleSharingDone( 
                        iEngine, KErrNone );
                    }
                }
            }
        CleanupStack::PopAndDestroy( &progressArr );
        }
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::DoCancel
// Cancels active object
// --------------------------------------------------------------------------
//
void CUpnpProgressWatcher::DoCancel()
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::DoCancel");
    iEngine.SetShareFileComplete( ETrue );
    iProgressInfo.Cancel();
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::SetShowCompleteNote
// determine need to show complete note, handle errors
// --------------------------------------------------------------------------
//
void CUpnpProgressWatcher::SetShowCompleteNote( 
    const TUpnpProgress& aProgress )
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::SetShowCompleteNote");

    if( !iShowCompleteNote )
        {
        if( aProgress.iImageVideoProgress.iProgressType != 
            TUpnpProgressInfo::EVisualStatus ||
            aProgress.iMusicProgress.iProgressType != 
            TUpnpProgressInfo::EVisualStatus)
            {
            iShowCompleteNote = ETrue;
            }
        }
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::SharingOngoing
// determine need to show complete note, handle errors
// --------------------------------------------------------------------------
//
TBool CUpnpProgressWatcher::SharingOngoing( const TUpnpProgress& aProgress )
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::SharingOngoing");
    TBool ret( EFalse );

    if( aProgress.iImageVideoProgress.iProgressType != 
        TUpnpProgressInfo::EVisualStatus ||
        aProgress.iMusicProgress.iProgressType !=
        TUpnpProgressInfo::EVisualStatus)
        {
        ret = ETrue;
        }
    return ret;
    }

// --------------------------------------------------------------------------
// CUpnpProgressWatcher::HandleErrorL
// determine need to show complete note, handle errors
// --------------------------------------------------------------------------
//
void CUpnpProgressWatcher::HandleErrorL( const TUpnpProgress& aProgress )
    {
    __LOG("[UPNP_ENGINE]\t CUpnpProgressWatcher::HandleIfErrorL");
    Cancel();
    if( aProgress.iError == KErrNoMemory || 
        aProgress.iError == KErrDiskFull )
        {
        // update UI
        TProgressInfos progressArr( KMaxSharingReqs );
        CleanupClosePushL( progressArr );
        progressArr.Append( aProgress.iImageVideoProgress );
        progressArr.Append( aProgress.iMusicProgress );
        
        if ( iEngine.Observer() )
            {
            iEngine.Observer()->HandleSharingProgress( 
                iEngine, progressArr );
            }
        CleanupStack::PopAndDestroy( &progressArr );
        iShowCompleteNote = EFalse;
        User::Leave( aProgress.iError );
        }
    }

// End of file