/*

* Copyright (c) 2004-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:    RSS plugin.*

*/

#include <e32base.h>

#include <sysutil.h>

#include <centralrepository.h>

#include <bautils.h>

#include <xml/parser.h>

#include "IptvDebug.h"

#include "MIptvEpgVodCallback.h"

#include "MIptvEpgLiveTvCallback.h"

#include "CIptvTimer.h"

#include <hash.h>

#include "CIptvEpgService.h"

#include "iptvlastwatcheddata.h"

#include "iptvlastwatchedapi.h"

#include "CIptvRssPlugin.h"

#include "CIptvRssDownload.h"

#include "CIptv3XmlContentHandler.h"

_LIT8( KMimeType, "text/xml" );

_LIT( KIptvRssFileName, "rss." );

_LIT( KIptvThumbnailExtension, ".jpg" );

_LIT( KIptvVCFGExtension, ".vcfg" );

_LIT( KIptvRssSearchFileName, "rsssearch." );

_LIT( KIptvAllFiles, "*.*" );

_LIT8( KIptvHexByteFormatStr, "%02x" );

const TInt64 KIptvRssUpdateSuccesInterval( 60 );

const TInt64 KIptvRssUpdateFailedInterval( 0 );

const TInt KIptvExtensionMaxSize( 5 );

const TInt KIptvRssPluginFreeSpace( 512000 ); // 500 KB

static const TInt KReadAtOnceLength( 1000 );

const TInt KIptvTime_200_microsecond( 200 );

const TInt KIptvHexCharInByte( 2 );

/**

* Enable this flag to update feed from local XML file. The path

* to XML file is defined with KIptvLocalTestFeed variable below.

*/

//#define IPTV_RSS_LOCAL_TEST

#ifdef IPTV_RSS_LOCAL_TEST

_LIT( KIptvLocalTestFeed, "C:\\videofeed.xml" );

#warning Local feed test flag IPTV_RSS_LOCAL_TEST has been defined!!!

#endif

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

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

// Symbian 2nd phase constructor can leave.

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

//

void CIptvRssPlugin::ConstructL()

    {

    IPTVLOGSTRING_LOW_LEVEL( "RSS Plugin --- CIptvRssPlugin::ConstructL" );

    User::LeaveIfError( iFs.Connect() );

    iDownload = CIptvRssDownload::NewL( *this, iFs, *iXmlContentHandler );

    iThumbnailDlAllowed = ThumbnailDlAllowedL();

    if ( iThumbnailDlAllowed )

        {

        IPTVLOGSTRING_LOW_LEVEL(

            "RSS Plugin --- CIptvRssPlugin::ConstructL --- Thumbnail downloading is allowed!" );

        }

    else

        {

        IPTVLOGSTRING_LOW_LEVEL(

            "RSS Plugin --- CIptvRssPlugin::ConstructL --- Thumbnail downloading is not allowed!" );

        }

    iParserIdle = CIdle::NewL( CActive::EPriorityIdle );

    iXmlContentHandler = CIptvXmlContentHandler::NewL( *this );

    iParser = CParser::NewL( KMimeType, *iXmlContentHandler );

    }

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

// Two-phased constructor.

// Create instance of concrete ECOM interface implementation

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

//

CIptvRssPlugin* CIptvRssPlugin::NewL()

    {

    IPTVLOGSTRING_LOW_LEVEL( "RSS Plugin --- CIptvRssPlugin::NewL" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CIptvRssPlugin::~CIptvRssPlugin()

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::~CIptvRssPlugin" );

    delete iItem;

    delete iParser;

    delete iDownload;

    delete iParserIdle;

    delete iXmlContentHandler;

    delete iXmlFileContent;

    delete iStartTimer;

    delete iMD5Calculator;

    iDlQueue.ResetAndDestroy();

    iIconList.ResetAndDestroy();

    iPreviouslyDownloadedAddresses.ResetAndDestroy();

    iPreviouslyDownloadedPaths.ResetAndDestroy();

    iFs.Close();

    iVodCallback = NULL;

    }

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

// C++ default constructor

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

//

CIptvRssPlugin::CIptvRssPlugin() :

    iXmlContentHandler( NULL ),

    iParser( NULL ),

    iParserIdle( NULL ),

    iDownload( NULL ),

    iVodCallback( NULL ),

    iXmlFileContent( NULL ),

    iStartTimer( NULL ),

    iServiceId( 0 ),

    iItem( NULL ),

    iDlThumbnail( EFalse ),

    iThumbnailDlAllowed( EFalse ),

    iParsingFailed( EFalse )

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::CIptvRssPlugin" );

    }

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

// From CIptvEpgPluginInterface

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

//

void CIptvRssPlugin::RunPlugin()

    {

    IPTVLOGSTRING_LOW_LEVEL( "RSS Plugin --- CIptvRssPlugin::RunPlugin" );

    // Timer removes UI jamming in update sequence.

    if ( !iStartTimer )

        {

        TRAP_IGNORE( iStartTimer =

            CIptvTimer::NewL( CActive::EPriorityUserInput, *this ) );

        }

    if ( iStartTimer )

        {

        if ( !iStartTimer->IsActive() )

            {

            iStartTimer->After( KIptvTime_200_microsecond );

            }

        }

    }

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

// Delayed plugin start.

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

//

void CIptvRssPlugin::TimerExpired( CIptvTimer* /* aTimer */ )

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "CIptvRssPlugin --- CIptvRssPlugin::TimerExpired" );

    TRAPD( error, DoTimerExpiredL() );

    if ( error != KErrNone )

        {

        IPTVLOGSTRING2_LOW_LEVEL(

            "RSS Plugin --- CIptvRssPlugin::TimerExpired --- Leave while DoTimerExpiredL() = %d",

            error );

        TRAP( error, PluginFailedL( EIptvDlNoError ) );

        if ( error != KErrNone )

            {

            IPTVLOGSTRING2_LOW_LEVEL(

                "RSS Plugin --- CIptvRssPlugin::TimerExpired --- Leave while PluginFailedL() = %d",

                error );

            }

        }

    }

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

// Delayed plugin start.

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

//

void CIptvRssPlugin::DoTimerExpiredL()

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::DoTimerExpiredL" );

    iDownload->InitializeL();

    RunPluginL();

    }

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

//  Start plugin.

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

//

void CIptvRssPlugin::RunPluginL()

    {

    IPTVLOGSTRING_LOW_LEVEL( "RSS Plugin --- CIptvRssPlugin::RunPluginL" );

    if ( ! iIsGroupOperation )

        {

        // If exist, delete old rss file

        if ( BaflUtils::FileExists( iFs, iRssPath ) )

            {

            BaflUtils::DeleteFile( iFs, iRssPath );

            }

        }

    // Clear obsolete thumbnail list.

    iIconList.ResetAndDestroy();

    // Clear already downloaded thumbnail list.

    iPreviouslyDownloadedAddresses.ResetAndDestroy();

    iPreviouslyDownloadedPaths.ResetAndDestroy();

    // Before we even start the download, we check that there is sensible

    // amount of free disk space for content guide and thumbnail files.

    TBool checkResult( EFalse );

    TRAPD(

        checkError,

        checkResult = SysUtil::DiskSpaceBelowCriticalLevelL(

            &iFs, KIptvRssPluginFreeSpace, EDriveC ) );

    if ( checkError != KErrNone || checkResult )

        {

        // Not enough space on disk, return immediately without any downloading.

        if ( iIsSearchOperation )

            {

            iVodCallback->ErrorL( KIptvErrorRssSearchFailed, EIptvDlDiskFull );

            }

        else

            {

            iVodCallback->ErrorL( KIptvErrorEpgUpdateFailed, EIptvDlDiskFull );

            }

        return;

        }

    // Callback EPG manager that plugin is started

    if ( iVodCallback )

        {

        iVodCallback->StartedL();

        }

    else

        {

        IPTVLOGSTRING_LOW_LEVEL(

            "RSS Plugin --- CIptvRssPlugin::RunPluginL --- iVodCallback is NULL" );

        }

#ifndef IPTV_RSS_LOCAL_TEST

    if ( ( EIptvRssAddServiceThumbnailToDlQueue == iAction ) ||

         ( EIptvRssAddItemThumbnailToDlQueue == iAction ) )

        {

        // Download only previously listed thumbnails.

        iParsingFailed = EFalse;

        DownloadThumbnailsL();

        }

    else

        {

        // Download RSS-file.

        iDownload->DownloadL(

            iServiceAddress,

            iRssPath,

            EFalse,

            KIptvEmptyDes,

            iLastUpdated );

        }

#else

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::RunPluginL --- Parsing XML from local filesystem!" );

    iRssPath.Copy( KIptvLocalTestFeed );

    DownloadFinishedL( EDownloadSucceeded, EIptvDlNoError );

#endif

    }

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

// Set callback pointer to MIptvEpgVodCallback. Plugin uses

// MIptvEpgVodCallback interface to supply Epg data to system.

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

//

void CIptvRssPlugin::SetVodCallback( MIptvEpgVodCallback* aVodCallback )

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::SetVodCallback" );

    iXmlContentHandler->SetVodCallback( aVodCallback );

    iVodCallback = aVodCallback;

    }

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

// Set callback pointer to MIptvEpgLiveTvCallback.

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

//

void CIptvRssPlugin::SetLiveTvCallback(

    MIptvEpgLiveTvCallback* /*aLiveTvCallback*/ )

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::SetLiveTvCallback" );

    }

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

// From CIptvEpgPluginInterface interface

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

//

void CIptvRssPlugin::SetServiceInformation(

    CIptvEpgService* aService,

    TBool aUseSearchAddress )

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::SetServiceInformation" );

    TIptvRSSAction action( EIptvRssService );

    if ( aUseSearchAddress )

        {

        action = EIptvRssSearch;

        }

    TRAP_IGNORE( SetServiceInformationL( aService, action ) );

    }

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

// From CIptvEpgPluginInterface interface

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

//

void CIptvRssPlugin::SetServiceInformationL(

    CIptvEpgService* aService,

    TIptvRSSAction aAction )

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::SetServiceInformationL" );

    if ( !aService )

        {

        User::Leave( KErrArgument );

        }

    iAction = aAction;

    iIsGroupOperation  =

        ( ( EIptvRssServiceGroup == iAction ) ||

          ( EIptvRssAddServiceThumbnailToDlQueue == iAction ) ||

          ( EIptvRssAddItemThumbnailToDlQueue == iAction ) );

    iIsSearchOperation = ( EIptvRssSearch == iAction );

    if ( ( EIptvRssAddServiceThumbnailToDlQueue == iAction ) ||

         ( EIptvRssAddItemThumbnailToDlQueue == iAction ) )

        {

        CIptvDownloadItem* item = CIptvDownloadItem::NewL();

        CleanupStack::PushL( item );

        item->iThumbnailUrl.Copy( aService->iAddress );

        item->iServiceThumbnail = ( EIptvRssAddServiceThumbnailToDlQueue == iAction );

        item->iId = aService->iServiceId;

        AddToDlQueueL( item );

        CleanupStack::Pop( item );

        }

    else

        {

        IPTVLOGSTRING2_LOW_LEVEL(

            "RSS Plugin --- CIptvRssPlugin::SetServiceInformationL --- USERNAME %S",

            &aService->iUserName );

        IPTVLOGSTRING2_LOW_LEVEL(

            "RSS Plugin --- CIptvRssPlugin::SetServiceInformationL --- PASSWORD %S",

            &aService->iPassword );

        iServiceId = aService->iServiceId;

        if ( iIsSearchOperation )

            {

            iServiceAddress.Copy( aService->SearchUrl() );

            }

        else

            {

            iServiceAddress.Copy( aService->iAddress );

            }

        iDownload->SetServiceInformation( aService );

        if ( iIsGroupOperation )

            {

            HBufC* path = HBufC::NewLC( KIptvMaxPath );

            TPtr16 pathPtr = path->Des();

            TBuf<KIptvCAContentUrlLength> url;

            url.Copy( iServiceAddress );

            // Get pathname for vcfg file.

            BuildUniqueuPathNameL(

                url,

                EIptvPathTmp,

                KIptvVCFGExtension,

                ETrue,

                pathPtr );

            iRssPath.Copy( *path );

            CleanupStack::PopAndDestroy( path );

            }

        else

            {

            // Get RSS temp file path

            TRAP_IGNORE( CIptvUtil::GetPathL( iFs, EIptvPathTmp, iRssPath ) );

            if ( iIsSearchOperation )

                {

                iRssPath.Append( KIptvRssSearchFileName );

                }

            else

                {

                iRssPath.Append( KIptvRssFileName );

                }

            TBuf<KIptvMaxPath> service;

            service.Num( TInt64( iServiceId ) );

            iRssPath.Append( service );

            }

        iLastUpdated = aService->iLastUpdated;

        IPTVLOGSTRING2_LOW_LEVEL(

            "RSS Plugin --- CIptvRssPlugin::SetServiceInformation --- RSS temp file : %S",

            &iRssPath );

        }

    }

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

// Handles download finished.

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

//

void CIptvRssPlugin::DownloadFinishedL( TInt aState, TIptvDlError aError )

    {

    IPTVLOGSTRING_LOW_LEVEL(

        "RSS Plugin --- CIptvRssPlugin::DownloadFinishedL" );

    TBuf<1> empty;

    if ( !iDlThumbnail )

        {

        switch ( aState )

            {

            case EDownloadFailed:

                {

                IPTVLOGSTRING_LOW_LEVEL(

                    "RSS Plugin --- CIptvRssPlugin::DownloadFinishedL --- EDownloadFailed" );

                PluginFailedL( aError );

                }

                break;

            case EDownloadSucceeded:

                {

                IPTVLOGSTRING_LOW_LEVEL(

                    "RSS Plugin --- CIptvRssPlugin::DownloadFinishedL --- EDownloadSucceeded" );

                if ( iIsGroupOperation )

                    {

                    // This is used for group VCFG file download indication.

                    iVodCallback->UpdateServiceThumbnailL( iRssPath, ETrue );

                    }

                else

                    {

                    ParseL();

                    }

                }

                break;

            case EDownloadNoNeed:

            case EDownloadAlreadyDownloaded:

                {

                IPTVLOGSTRING_LOW_LEVEL(

                    "RSS Plugin --- CIptvRssPlugin::DownloadFinishedL --- EDownloadNoNeed" );

                // When rss file has not been changed, also thumnails are

                // assumed not having been changed.

                if ( iIsGroupOperation )

                    {

                    iVodCallback->ErrorL(

                        KIptvContentUpdateCompleted,

                        EIptvDlNoErrorUpToDate );

                    iVodCallback->UpdateServiceThumbnailL( iRssPath, ETrue );

                    }

                else

                    {

                    PluginSucceededL();

                    }

                }

                break;

            default:

                break;

            }

        }

    else

        {

        if ( iItem )

            {

            if ( iItem->iServiceThumbnail )