/*

* 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:    Implementation of the scheduled download plugin engine.*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <e32cmn.h>

#include <s32mem.h>

#include <e32std.h>

#include <e32base.h>

#include <e32msgqueue.h>

#include <ipvideo/CCseScheduledProgram.h>

#include <ipvideo/MCsePluginObserver.h>

#include "IptvLiveDataStructures.h"

#include <hwrmpowerstatesdkpskeys.h>

#include <commdb.h>

#include "IptvDebug.h"

#include <CProfileChangeNotifyHandler.h>

#include <Profile.hrh>

#include <MProfileEngine.h>

#include "CIptvMediaContent.h"

#include "vcnsscheduleddownloadpluginengine.h"

#include "iptvbatterywatcher.h"

#include "iptvphoneregistrationwatcher.h"

#include "vcnsscheduleddownloadmpxclient.h"

// MACROS

#define RETURNONERROR(e) \

    { \

    if ( ( e ) != KErrNone ) \

        { \

        IPTVLOGSTRING2_HIGH_LEVEL( \

            ">>> CIptvScheduledDownloadPluginEngine return with error code: %d", ( e ) ); \

        return; \

        } \

    }

// LOCAL CONSTANTS AND MACROS

const TInt KIptvTimeoutInMicroseconds = 15 * 60 * 1000 * 1000 ; // 15 minutes

const TInt KIptvSearchStringmaxLen = 10;

const TInt KIptvGetAll = 0;

const TInt KIptvNoFileOrDrive = 0;

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

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

// CIptvScheduledDownloadPluginEngine::NewL

//

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

//

CIptvScheduledDownloadPluginEngine* CIptvScheduledDownloadPluginEngine::NewL(

        MCsePluginObserver& aObserver )

	{	

	CIptvScheduledDownloadPluginEngine* self =

	        new ( ELeave ) CIptvScheduledDownloadPluginEngine( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( );    

    CleanupStack::Pop( self );    

    return self;		

	}

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

// CIptvScheduledDownloadPluginEngine::ConstructL

//

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

//

void CIptvScheduledDownloadPluginEngine::ConstructL()

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>> CIptvScheduledDownloadPluginEngine::ConstructL");

	iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

	iVodDownloads = CIptvVodDlDownloadList::NewL();

    iIptvServiceManagementClient = CIptvServiceManagementClient::NewL( *this );

    iBatteryWatcher = CIptvBatteryWatcher::NewL();

    iBatteryWatcher->AddObserverL( this );

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    iProfChangeHandler = CProfileChangeNotifyHandler::NewL( this );

    iPhoneRegistrationWatcher = CIptvPhoneRegistrationWatcher::NewL();

    iPhoneRegistrationWatcher->AddObserverL( this );

    IPTVLOGSTRING_HIGH_LEVEL("<<< CIptvScheduledDownloadPluginEngine::ConstructL");

	}

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

// CIptvScheduledDownloadPluginEngine::CIptvScheduledDownloadPluginEngine

//

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

//

CIptvScheduledDownloadPluginEngine::CIptvScheduledDownloadPluginEngine(

        MCsePluginObserver& aObserver ) :

        CTimer( EPriorityNormal ), iObserver( aObserver )

    {

	}

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

// CIptvScheduledDownloadPluginEngine::~CIptvScheduledDownloadPluginEngine

//

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

//	

CIptvScheduledDownloadPluginEngine::~CIptvScheduledDownloadPluginEngine()

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>> CIptvScheduledDownloadPluginEngine::~CIptvScheduledDownloadPluginEngine");

    // Set error value to KErrAbort. This will cause nearly instant return from 

    // RunTaskL -method in case we're aborting plugin execution. This would mean

    // that we're actually running dead code. Class is already destroyed, but the

    // stack is still alive and kicking. This isn't a problems unless we change

    // internal class variables (class is destroyed, but the stack is still there).

    if ( iErrorReason )

        {

        *iErrorReason = KErrAbort;

        }

    // Uses iActiveSchedulerWait so pointer must exists.

    if ( iActiveSchedulerWait )

        {

        ActiveWait( EFalse );

        }

    delete iPhoneRegistrationWatcher;    

    delete iProfChangeHandler;    

    delete iBatteryWatcher;	

	delete iVodDlClient;    

    delete iIptvVodContentClient;    

    delete iIptvServiceManagementClient;    

    delete iService;

	delete iVodDownloads;	

    delete iActiveSchedulerWait;

	iEcgList.ResetAndDestroy();

	iCategoryList.ResetAndDestroy();

    IPTVLOGSTRING_HIGH_LEVEL("<<< CIptvScheduledDownloadPluginEngine::~CIptvScheduledDownloadPluginEngine");

	}

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

// CIptvScheduledDownloadPluginEngine::RunTaskL

//

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

//	

void CIptvScheduledDownloadPluginEngine::RunTaskL(

            CCseScheduledProgram& aProg,

            TInt& aEngineReturnValue )

	{

    IPTVLOGSTRING_HIGH_LEVEL(">>> CIptvScheduledDownloadPluginEngine::RunTaskL");

    TInt errorReason( KErrNone );

    iErrorReason = &errorReason;

    iState = EStarted;

    RestartTimeoutTimer();

    //  Check that we are not in offline mode, reschedule if we are

    CheckOfflineModeL();

    aEngineReturnValue = errorReason;

    RETURNONERROR( errorReason )

	// Get used Service ID

	iServiceID = GetServiceIdL( aProg );

    if (iIptvVodContentClient)

        {

        delete iIptvVodContentClient;

        iIptvVodContentClient = NULL;

        }

    iIptvVodContentClient = CIptvVodContentClient::NewL( iServiceID, *this );

	// Check Battery Status

	GetBatteryStatus();

	aEngineReturnValue = errorReason;

    RETURNONERROR( errorReason )

    //  Get and check the used IAP

    GetUsableIapL();

    aEngineReturnValue = errorReason;

	RETURNONERROR( errorReason )

    iState = EUpdatingContentGuide;

    //  Remember the time, this will be used as last successfull download time

    TTime now;

    now.HomeTime();

    // Update ECG, blocks until the update either is either finished or fails

    UpdateEpgL();

    aEngineReturnValue = errorReason;

	RETURNONERROR( errorReason);

	RestartTimeoutTimer();

    //  Update epg and start downloads

    LoadContentL();

    aEngineReturnValue = errorReason;

	RETURNONERROR( errorReason )

    //  Are we downloading

    if (iState == EDownloadingFiles)

        {

        //  This block until the files are downloaded

        IPTVLOGSTRING_HIGH_LEVEL("CIptvScheduledDownloadPluginEngine::RunTaskL starting to wait the downloads to finish");

        ActiveWait( ETrue );

        }

    aEngineReturnValue = errorReason;        

	RETURNONERROR( errorReason )

    IPTVLOGSTRING_HIGH_LEVEL("CIptvScheduledDownloadPluginEngine::RunTaskL downloads finished, updating schedules");

    iState = EFinished;

    //  Update all schedules by changing the last successfull download time

    UpdateLastDownloadTimeL( now );

    iObserver.PluginCompleted( KErrNone );

    IPTVLOGSTRING_HIGH_LEVEL("<<< CIptvScheduledDownloadPluginEngine::RunTaskL");

	}

// from CTimer, CActive

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

// CIptvScheduledDownloadPluginEngine::RunL

//

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

//

void CIptvScheduledDownloadPluginEngine::RunL()

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>> CIptvScheduledDownloadPluginEngine::RunL");

    //  No activity in KTimeoutInMilliseconds

    //  Assuming some kind of error situation and aborting all activities

    *iErrorReason = KErrTimedOut;

    CancelDownloads();

    ActiveWait( EFalse );

    IPTVLOGSTRING_HIGH_LEVEL("<<< CIptvScheduledDownloadPluginEngine::RunL");

    }

//  from MIptvServiceManagementClientObserver

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

// CIptvScheduledDownloadPluginEngine::AddServiceResp

//

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

//	

void CIptvScheduledDownloadPluginEngine::AddServiceResp(

        TRespStatus /*aRespStatus*/)

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>><<< CIptvScheduledDownloadPluginEngine::AddServiceResp");

    }

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

// CIptvScheduledDownloadPluginEngine::UpdateServiceResp

//

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

//	

void CIptvScheduledDownloadPluginEngine::UpdateServiceResp(

        TRespStatus /*aRespStatus*/)

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>><<< CIptvScheduledDownloadPluginEngine::UpdateServiceResp");

    }

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

// CIptvScheduledDownloadPluginEngine::DeleteServiceResp

//

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

//	

void CIptvScheduledDownloadPluginEngine::DeleteServiceResp(

        TRespStatus /*aRespStatus*/)

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>><<< CIptvScheduledDownloadPluginEngine::DeleteServiceResp");

    }

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

// CIptvScheduledDownloadPluginEngine::GetServicesResp

//

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

//	

void CIptvScheduledDownloadPluginEngine::GetServicesResp(

        TRespStatus /*aRespStatus*/, 

        CDesC8ArraySeg* /*aServicesArray*/)

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>><<< CIptvScheduledDownloadPluginEngine::GetServicesResp");

    }

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

// CIptvScheduledDownloadPluginEngine::GetUsedIapResp

//

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

//	

void CIptvScheduledDownloadPluginEngine::GetUsedIapResp(

        TUint32 /*aIapId*/,

        const TDesC& /*aIapName*/,

        CIptvNetworkSelection::TConnectionPermission /*aConnectionPermission*/,

        TBool /*aWlanWhenGPRS*/,

        CIptvNetworkSelection::TRespStatus /*aRespStatus*/ )

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>><<< CIptvScheduledDownloadPluginEngine::GetUsedIapResp");

    }

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

// CIptvScheduledDownloadPluginEngine::ServerShutdownResp

//

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

//	

void CIptvScheduledDownloadPluginEngine::ServerShutdownResp(

        TRespStatus /*aRespStatus*/)

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>><<< CIptvScheduledDownloadPluginEngine::ServerShutdownResp");

    }

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

// CIptvScheduledDownloadPluginEngine::HandleSmEvent

//

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

//	

void CIptvScheduledDownloadPluginEngine::HandleSmEvent(

        CIptvSmEvent& /*aEvent*/)

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>><<< CIptvScheduledDownloadPluginEngine::HandleSmEvent");

    }

// from MIptvVodContentClientObserver

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

// CIptvScheduledDownloadPluginEngine::HandleEpgManagerMsgL

//

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

//	

void CIptvScheduledDownloadPluginEngine::HandleEpgManagerMsgL(

        TInt aMsg,

        TInt /*aInfo*/,

        TIptvServiceId /*aServiceId*/)

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>> CIptvScheduledDownloadPluginEngine::HandleEpgManagerMsgL");

    IPTVLOGSTRING2_HIGH_LEVEL("CIptvScheduledDownloadPluginEngine::HandleEpgManagerMsgL, msg = %d", aMsg);

	switch (aMsg)

		{

		case KIptvErrorEpgUpdateFailed:

		    {

		    //  EPG update failed for some reason, try again later

		    *iErrorReason = EReschedule;

		    ActiveWait( EFalse );

		    }

		    break;

		case KIptvVodUpdateNotStarted:

		case KIptvErrorEpgUpdateSuccessed:

		    {

		    if (iState == EUpdatingContentGuide)

		        {

		        ActiveWait( EFalse );

		        }

		    }

			break;	

		case KIptvErrorVodNoIap:

		    {

		    if (iState == EUpdatingContentGuide)

		        {

		        IPTVLOGSTRING_HIGH_LEVEL("CIptvScheduledDownloadPluginEngine::HandleEpgManagerMsgL, setting iap");

		        iIptvVodContentClient->SetIapL( iIapId );

		        }

		    }

		    break;

		case KIptvVodUpdateStarted:

		case KIptvErrorEpgUpdateStopped:

		case KIptvContentUpdateCompleted:

		case KIptvServiceThumbnailDownloaded:

		case KIptvContentThumbnailDownloaded:

		default:

		    {

		    // No operation, update still in progress.

		    }

			break;

        }

    RestartTimeoutTimer();

    IPTVLOGSTRING_HIGH_LEVEL("<<< CIptvScheduledDownloadPluginEngine::HandleEpgManagerMsgL");

    }

//  from MIptvVodDlClientObserver

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

// CIptvScheduledDownloadPluginEngine::HandleVodDlDownloadEvent

//

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

//	

void CIptvScheduledDownloadPluginEngine::HandleVodDlDownloadEvent(

                CIptvVodDlDownloadEvent& aEvent) 

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>> CIptvScheduledDownloadPluginEngine::HandleVodDlDownloadEvent");

    IPTVLOGSTRING2_HIGH_LEVEL("CIptvScheduledDownloadPluginEngine::HandleVodDlDownloadEvent, event = %d", aEvent.iEvent);

    switch (aEvent.iEvent)

        {

        case CIptvVodDlDownloadEvent::EDownloadState:

            {

            switch ( aEvent.iState )

                {

                case KIptvVodDlDownloadInQueue:

                case KIptvVodDlDownloadStarting:

                case KIptvVodDlDownloadDeleted:

                case KIptvVodDlDownloadPermanentlyPausing:

                case KIptvVodDlDownloadCreated:

                case KIptvVodDlDownloadIdle:

                case KIptvVodDlDownloadGlobalFileIdIsValid:

                case KIptvVodDlDownloadRunning:

                case KIptvVodDlDownloadPausing:

                case KIptvVodDlDownloadPaused:

                    {

                    }

                    break;

                case KIptvVodDlDownloadPermanentlyPaused:

                case KIptvVodDlDownloadFailed:

                    {

                    if (DeleteFromList( aEvent.iServiceId, aEvent.iContentId ))

                        {

                        TRAP_IGNORE( iVodDlClient->CancelDownloadL( 

                                aEvent.iServiceId,

                                aEvent.iContentId ) )

                        }

                    }

                    break;

                case KIptvVodDlDownloadDeletedCompletely:

                case KIptvVodDlDownloadSucceeded:

                    {

                    DeleteFromList( aEvent.iServiceId, aEvent.iContentId );

                    }

                    break;

                default:

                    break;            

                }

            }

            break;

        case CIptvVodDlDownloadEvent::EDownloadReqSucceeded:

        case CIptvVodDlDownloadEvent::ECancelReqFailed:

        case CIptvVodDlDownloadEvent::ECancelReqSucceeded:

        case CIptvVodDlDownloadEvent::EDownloadReqFailed:

        case CIptvVodDlDownloadEvent::EDownloadItemsModified:

        break;

        default:

        break;

        }

    RestartTimeoutTimer();

    IPTVLOGSTRING_HIGH_LEVEL("<<< CIptvScheduledDownloadPluginEngine::HandleVodDlDownloadEvent");

    }

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

// CIptvScheduledDownloadPluginEngine::BatteryLow

//

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

//	

void CIptvScheduledDownloadPluginEngine::BatteryLow()

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>> CIptvScheduledDownloadPluginEngine::BatteryLow");

    //  Set error reason, cancel downloads and finish the plugin

    *iErrorReason = KErrBadPower;

    CancelDownloads();

    ActiveWait( EFalse );

    IPTVLOGSTRING_HIGH_LEVEL("<<< CIptvScheduledDownloadPluginEngine::BatteryLow");

    }

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

// CIptvScheduledDownloadPluginEngine::HandleActiveProfileEventL

//

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

//	

void CIptvScheduledDownloadPluginEngine::HandleActiveProfileEventL(

            TProfileEvent aProfileEvent,

            TInt aProfileId ) 

    {

    IPTVLOGSTRING_HIGH_LEVEL(">>> CIptvScheduledDownloadPluginEngine::HandleActiveProfileEventL");

    if (aProfileEvent == EProfileNewActiveProfile)

        {

        if (aProfileId == EProfileOffLineId)

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvScheduledDownloadPluginEngine::HandleActiveProfileEventL phone changed to offline mode");

            *iErrorReason = EReschedule;

            CancelDownloads();

            ActiveWait( EFalse );

            }

        }

    IPTVLOGSTRING_HIGH_LEVEL("<<< CIptvScheduledDownloadPluginEngine::HandleActiveProfileEventL");

    }

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