/*

* Copyright (c) 2002-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:    Controls epg services update*

*/

#include "IptvDebug.h"

#include "CIptvEpgSession.h"

#include "IptvEngineUids.h"

#include <bautils.h>

#include "CIptvEpgPluginInterface.h"

#include "TIptvRssSearchQuery.h"

#include "CIptvEpgDatabase.h"

#include "IptvLiveEpgConstants.h"

#include "CIptvEpgDb.h"

#include "CIptvService.h"

#include "CIptvEpgService.h"

#include "CIptvMyVideosGlobalFileId.h"

#include "CIptvEpgVodCallbackImpl.h"

#include "CIptvEpgLiveTvCallbackImpl.h"

#include "CIptvEpgVodClientImpl.h"

#include "CIptvServer.h"

#include "CIptvEpgManagerUpdater.h"

#include "CIptvServiceManager.h"

#include "CIptvEpgVodMsqQueue.h"

#include "CIptvEpgManagerImpl.h"

#include "CIptvSearchManager.h"

#include "CIptvVodDlDownloadList.h"

#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)

#include "CIptvVodDownloadManager.h"

#include "iptvvideostoragemyvideosadaptation.h"

#include "iptvvideostoragesideloaderobserver.h"

#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)

#include "CIptvMyVideosGlobalFolderId.h"

#include "CIptvMyVideosFolder.h"

#include "vcxgroupupdater.h"

_LIT( KIptvEmptyAddress, "" );

#ifdef _DEBUG

const TInt KIptvHundred = 100;

#endif

#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)

static void CleanupVideoPointerArray( TAny* item )

    {

    ( ( RPointerArray<CIptvMyVideosVideoBriefDetails>* ) item )->ResetAndDestroy();

    }

static void CleanupFolderPointerArray( TAny* item )

    {

    ( ( RPointerArray<CIptvMyVideosFolder>* ) item )->ResetAndDestroy();

    }

static void CleanupFolderIdPointerArray( TAny* item )

    {

    ( ( RPointerArray<CIptvMyVideosGlobalFolderId>* ) item )->ResetAndDestroy();

    }

#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)

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

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

// CIptvEpgSession::CIptvEpgSession

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

// might leave.

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

//

CIptvEpgSession::CIptvEpgSession(

    CIptvEpgDb* aEpgDb,

    TUint32 aServiceId,

    CIptvEpgVodMsqQueue* aMsgQueue,

    CIptvServer& aServer,

    TBool aPluginCanRun ) :

    iServer( aServer ),

    iUpdater( NULL ),

    iVodClient( NULL ),

    iPlugin( NULL ),

    iVodCallback( NULL ),

    iEpgDb( aEpgDb ),

    iService( NULL ),

    iMsgQueue( aMsgQueue ),

    iPluginStarted( EFalse ),

    iDeleteDatabase( EFalse ),

    iServiceId( aServiceId ),

    iPluginCanRun( aPluginCanRun ),

    iReferenceCount( 0 ),

    iInitialized( EFalse ),

    iIsIap( EFalse ),

    iIap( 0 ),

    iUpdatePending( EFalse ),

    iReady( EFalse )

    {

    }

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

// CIptvEpgSession::CIptvEpgSession

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

// might leave.

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

//

CIptvEpgSession::CIptvEpgSession(

    CIptvEpgDatabase* aLiveTvDb,

    TUint32 aServiceId,

    CIptvEpgVodMsqQueue* aMsgQueue,

    CIptvServer& aServer,

    TBool aPluginCanRun ) :

    iServer( aServer ),

    iUpdater( NULL ),

    iVodClient( NULL ),

    iPlugin( NULL ),

    iVodCallback( NULL ),

    iEpgDb( NULL ),

    iLiveTvDatabase( aLiveTvDb ),

    iService( NULL ),

    iMsgQueue( aMsgQueue ),

    iPluginStarted( EFalse ),

    iDeleteDatabase( EFalse ),

    iServiceId( aServiceId ),

    iPluginCanRun( aPluginCanRun ),

    iReferenceCount( 0 ),

    iInitialized( EFalse ),

    iIsIap( EFalse ),

    iIap( 0 ),

    iUpdatePending( EFalse ),

    iReady( EFalse )

    {

    }

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

// CIptvEpgSession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

TInt CIptvEpgSession::ConstructL()

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgSession::ConstructL" );

    TInt error = iFs.Connect();

    if ( error != KErrNone )

        {

        User::Leave( error );

        }

    iSearchManager = iServer.GetSearchManagerL( iServiceId, *this, iMsgQueue );

    error = GetServiceInformationL();

    iSearchManager->SetServiceL( iService );

    if ( ! iSearchManager->IsSearchPossible() )

        {

        // Nullify the pointer. Search not supported so no need to use the implementation.

        iServer.RemoveQueueFromSearchManagerL( iServiceId, iMsgQueue );

        iSearchManager = NULL;

        }

    if ( error == KErrNone )

        {

        if ( iEpgDb )

            {

            iVodClient = CIptvEpgVodClientImpl::NewL( *iEpgDb, *this, iSearchManager );

            }

        }

    iUpdater = CIptvEpgManagerUpdater::NewL( *this );

    User::LeaveIfError( iServer.iServiceManager->RegisterObserver( this ) );

    return error;

    }

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

// CIptvEpgSession::NewL

// Two-phased constructor.

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

//

CIptvEpgSession* CIptvEpgSession::NewL(

    CIptvEpgDb* aEpgDb,

    TUint32 aServiceId,

    CIptvEpgVodMsqQueue* aMsgQueue,

    CIptvServer& aServer,

    TBool aPluginCanRun,

    TInt& aError )

    {

    CIptvEpgSession* self = new( ELeave ) CIptvEpgSession(

        aEpgDb,

        aServiceId,

        aMsgQueue,

        aServer,

        aPluginCanRun );

    CleanupStack::PushL( self );

    aError = self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CIptvEpgSession::NewL

// Two-phased constructor.

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

//

CIptvEpgSession* CIptvEpgSession::NewL(

    CIptvEpgDatabase* aLiveTvDb,

    TUint32 aServiceId,

    CIptvEpgVodMsqQueue* aMsgQueue,

    CIptvServer& aServer,

    TBool aPluginCanRun,

    TInt& aError )

    {

    CIptvEpgSession* self = new( ELeave ) CIptvEpgSession(

        aLiveTvDb,

        aServiceId,

        aMsgQueue,

        aServer,

        aPluginCanRun );

    CleanupStack::PushL( self );

    aError = self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CIptvEpgSession::~CIptvEpgSession()

// Destructor.

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

//

CIptvEpgSession::~CIptvEpgSession()

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgSession::~CIptvEpgSession" );

	if ( iPluginStarted && iServer.EpgUpdating() )

        {

        iServer.SetEpgUpdating( EFalse );

        }

    delete iUpdater;

    delete iPlugin;

    delete iGroupUpdater;

    REComSession::FinalClose();

    delete iVodCallback;

    delete iLiveTvCallback;

    delete iService;

    delete iVodClient;

    if ( iDeleteDatabase )

        {

        // iDeleteDatabase basically means service is being deleted.

        // Therefore we also need to make sure search manager clears

        // it's data to avoid i.e. thumbnails to stay in device even though

        // the service itself has been deleted

        if ( iSearchManager )

            {

            iSearchManager->ClearAllResults();

            }

        // CIptvEpgDb will delete database file after it has been closed

        }

    if ( iSearchManager )

        {

        TRAP_IGNORE( iServer.RemoveQueueFromSearchManagerL( iServiceId, iMsgQueue ) );

        }

    iFs.Close();

    iServer.iServiceManager->DeRegisterObserver( this );

    CIptvEpgManagerImpl& epgManager = iServer.GetEpgManager();

    epgManager.CloseSession( iServiceId );

    }

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

// CIptvEpgSession::UpdateEcg

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

TInt CIptvEpgSession::UpdateEcg( TBool aForceUpdate )

    {

    IPTVLOGSTRING2_LOW_LEVEL( "CIptvEpgSession::UpdateEcg, aForce: %d", aForceUpdate );

    TInt retval( KErrNone );

    TRAPD( err, retval = GetServiceInformationL() );

    if ( iService && err == KErrNone && retval == KErrNone )

        {

        switch ( iService->iServiceType )

            {

            case CIptvService::EVod:

            case CIptvService::EVodCast:

            case CIptvService::EServiceGroup:

                {

                TRAPD( error, UpdateVodEcgL( aForceUpdate ) );

                return error;

                }

            case CIptvService::ELiveTv:

                {

                TInt err( UpdateLiveEpg() );

                return err;

                }

            case CIptvService::EOther:

                break;

            default:

                break;

            }

        }

    TInt status( KErrNone );

    if ( err != KErrNone )

        {

        status = err;

        }

    else if ( retval != KErrNone )

        {

        status = retval;

        }

    return status;

    }

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

// CIptvEpgSession::Search

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

//

TInt CIptvEpgSession::Search( TIptvRssSearchQuery& aSearchQuery )

    {

    if ( ! iIsIap )

        {

        // Service id = 0 because we dont have to bring this information

        // over IPC. Service ID is already on the client side.

        IPTVLOGSTRING_LOW_LEVEL( "" );

        IPTVLOGSTRING_LOW_LEVEL( "------------------CIptvEpgSession::Search------------------" );

        IPTVLOGSTRING_LOW_LEVEL( "" );

        IPTVLOGSTRING_LOW_LEVEL( "SEARCH CANCELLED! NO IAP! KIptvErrorVodNoIap sent to client." );

        IPTVLOGSTRING_LOW_LEVEL( "Update pending! Update is made when we get IAP!" );

        IPTVLOGSTRING_LOW_LEVEL( "" );

        IPTVLOGSTRING_LOW_LEVEL( "------------------CIptvEpgSession::Search------------------" );

        IPTVLOGSTRING_LOW_LEVEL( "" );

        // Now we disable update pending flag. There is a reason this is done:

        // If we start a vod UI and automatic update is initiated and user

        // is prompted for IAP selection while updating normal vod and that

        // dialog has been canceled -> user does not want to start vod update.

        // Then user select 'Search' and IAP dialog is prompted again. Now

        // if we dont disable update pending flag also vod content update

        // is started and that's something user already decided not to do.

        // This is the reason update pending flag is disabled here.

        iUpdatePending = EFalse;

        TRAP_IGNORE( SendMessageToClientL( KIptvErrorRssSearchNoIap, 0 ) );

        return KErrCouldNotConnect;

        }

    TInt error( KErrNone );

    TRAP_IGNORE( DoSearchL( error ) );

    if ( error != KErrNone )

        {

        return error;

        }

    return iSearchManager->Search( aSearchQuery );

    }

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

// CIptvEpgSession::DoSearchL

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

//

void CIptvEpgSession::DoSearchL( TInt& error )

    {

    // Refresh the service data. This is done to prevent situation where

    // search address in the service has been changed.

    GetServiceInformationL();

    SendMessageToClientL( KIptvErrorRssSearchStarted, 0 );

    if ( iSearchManager )

        {

        // Before starting a new search, we gather a list of Content IDs that have

        // been used by downloads started from previous search results. This way the

        // Search Manager knows not to re-use the same IDs again, and we avoid the

        // possible ID collisions between old and new downloads.

        //

        UpdateSearchUsedContentIdsListL();

        iSearchManager->SetServiceL( iService );

        }

    else

        {

        error = KErrNotSupported;

        SendMessageToClientL( KIptvErrorRssSearchFailed, error );

        }

    }

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

// CIptvEpgSession::UpdateSearchUsedContentIdsListL

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

void CIptvEpgSession::UpdateSearchUsedContentIdsListL()

    {

    RArray<TInt> usedIdArray;

    CleanupClosePushL( usedIdArray );

#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)    

    // First gather a list of used Content IDs from Download Manager.

    if ( iServer.iVodDownloadManager )

        {

        CIptvVodDlDownloadList* downloadList = CIptvVodDlDownloadList::NewL();

        if ( downloadList )

            {

            CleanupStack::PushL( downloadList );

            // Note, the method leaves if list is empty.

            TRAPD( dlMgrError, iServer.iVodDownloadManager->GetDownloadListL( *downloadList ) );

            if ( dlMgrError == KErrNone )

                {

                for ( TInt i = 0; i < downloadList->iList.Count(); i++ )

                    {

                    CIptvVodDlDownloadListItem* downloadItem = downloadList->iList[i];

                    // Check for downloads with our service Id, and "search" content Id.

                    if ( downloadItem->iServiceId == iService->iServiceId &&

                         downloadItem->iContentId >= KIptvRssSearchInitialContentId &&

                         downloadItem->iContentId != ( TIptvContentId ) KErrNotFound )

                        {

                        usedIdArray.InsertInOrder( downloadItem->iContentId );

                        }

                    }

                }

            CleanupStack::PopAndDestroy( downloadList );

            }

        }

#else

    // REL6: Similar functionality with MPX Collection?

#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)

#if defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)

    // Then gather a list of used Content IDs from My Videos Manager.

    TUint32 totalNum = 0;

    RPointerArray<CIptvMyVideosVideoBriefDetails> files;

    TCleanupItem cleanupVideo( CleanupVideoPointerArray, &files );

    CleanupStack::PushL( cleanupVideo );

    RPointerArray<CIptvMyVideosFolder> folders;

    TCleanupItem cleanupFolder( CleanupFolderPointerArray, &folders );

    CleanupStack::PushL( cleanupFolder );

    RPointerArray<CIptvMyVideosGlobalFolderId> folderIds;

    TCleanupItem cleanupFolderId( CleanupFolderIdPointerArray, &folderIds );

    CleanupStack::PushL( cleanupFolderId );

    CIptvMyVideosGlobalFolderId* rootFolder = CIptvMyVideosGlobalFolderId::NewRootFolderL();

    CleanupStack::PushL( rootFolder );

    iServer.GetVideoStorageAdaptationL()->GetFolderListL(

        *rootFolder,

        0,

        0,

        totalNum,

        folders );

    for ( TInt i = 0; i < folders.Count(); i++ )

        {

        CIptvMyVideosGlobalFolderId* newFolderId = CIptvMyVideosGlobalFolderId::NewLC();

        newFolderId->iDrive    = folders[i]->iFolderId->iDrive;

        newFolderId->iFolderId = folders[i]->iFolderId->iFolderId;

        folderIds.AppendL( newFolderId );

        CleanupStack::Pop( newFolderId );

        }

    folderIds.AppendL( rootFolder );

    CleanupStack::Pop( rootFolder );

    for ( TInt j = 0; j < folderIds.Count(); j++ )

        {

        iServer.GetVideoStorageAdaptationL()->GetVideoListL(

            *( folderIds[j] ),

            0,

            0,

            totalNum,

            files );

        for ( TInt i = 0; i < files.Count(); i++ )

            {

            // Check for downloads with our service Id, and "search" content Id.

            if ( files[i]->iServiceId == iService->iServiceId &&

                 files[i]->iContentId >= KIptvRssSearchInitialContentId &&

                 files[i]->iContentId != ( TIptvContentId ) KErrNotFound )

                {

                usedIdArray.InsertInOrder( files[i]->iContentId ); // Note, prevents duplicates.

                }

            }

        files.ResetAndDestroy();

        }

    CleanupStack::PopAndDestroy( &folderIds );

    CleanupStack::PopAndDestroy( &folders );

    CleanupStack::PopAndDestroy( &files );

#else

    // REL6: Similar functionality with MPX Collection?

#endif // defined(__SERIES60_30__) || defined(__SERIES60_31__) || defined(__SERIES60_32__)