/*

* 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: 

*

*/

// Version : %version: Rel6_50 %

// INCLUDE FILES

#include <bldvariant.hrh>

#include <bautils.h>

#include "IptvDebug.h"

#include "CIptvIapList.h"

#include "CIptvVodContentClient.h"

#include "CIptvServiceManagementClient.h"

#include "vcxnsserviceproviderobserver.h"

#include "vcxnsserviceclienthandler.h"

#include "vcxnscontentclienthandler.h"

#include "vcxnsserviceprovider.h"

#include "vcxnscontentprovider.h"

#include "vcxnscategoryprovider.h"

#include "vcxnscategory.h"

#include "vcxnsuiengine.h"

#include "vcxnsupdateprogresshandler.h"

#include "vcxnscontentsearchhandler.h"

_LIT( KVcxNsRtspProtocol, "rtsp://" );

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

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

// CVcxNsServiceProvider::CVcxNsServiceProvider()

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

//

CVcxNsServiceProvider::CVcxNsServiceProvider( CVcxNsUiEngine& aUiEngine ) : iUiEngine( aUiEngine )

    {

    }

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

// CVcxNsServiceProvider::NewL()

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

//

CVcxNsServiceProvider* CVcxNsServiceProvider::NewL( CVcxNsUiEngine& aUiEngine )

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceProvider::NewL()");

    CVcxNsServiceProvider* self =  new (ELeave) CVcxNsServiceProvider( aUiEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxNsServiceProvider::ConstructL()

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

//

void CVcxNsServiceProvider::ConstructL()

    {

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

    }

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

// CVcxNsServiceProvider::~CVcxNsServiceProvider()

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

//

CVcxNsServiceProvider::~CVcxNsServiceProvider()

    {

    iUpdateQueue.Reset();

    iServiceObservers.Reset();

    iServiceList.ResetAndDestroy();

    iFs.Close();

    }

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

// CVcxNsServiceProvider::GetSubscribedServicesL()

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

//

RPointerArray<CVcxNsService>& CVcxNsServiceProvider::GetSubscribedServicesL()

    {

    IPTVLOGSTRING_HIGH_LEVEL(

        "UI Engine ## CVcxNsServiceProvider::GetSubscribedServicesL()");

    if( iServiceList.Count() > 0 )

        {

        return iServiceList;

        }

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    CDesC8ArraySeg* services = NULL;

    TUint32 flags = 0;

    TInt error = iUiEngine.GetServiceClientHandlerL()->GetServiceManagementClientL()->GetServicesL( 

                         CIptvServiceManagementClient::ESelectedServices 

                         || CIptvServiceManagementClient::EBrowser,

                         CIptvServiceManagementClient::EDisplayOrderDescending,

                         services,

                         respStatus );

    if ( error == KErrNone )

        {

        CleanupStack::PushL( services );

        CIptvService* service = CIptvService::NewL();

        CleanupStack::PushL( service );

        for ( TInt i = 0; i < services->Count(); i++ )

            {

            service->SetL( services->MdcaPoint(i) );

            flags = service->GetFlags();

            if ( ( flags & CIptvService::ESelected ) && 

                ( ( service->GetType() == CIptvService::EVod )

                    || ( service->GetType() == CIptvService::EVodCast )

                    || ( service->GetType() == CIptvService::EServiceGroup ) ) )

                {

  		    	CVcxNsService* newService = CVcxNsService::NewL();

                CleanupStack::PushL( newService );

  		    	newService->SetServiceId( service->GetId() );

  		    	newService->SetNameL( service->GetName() );

  		    	newService->SetGroupId( service->GetGroupId() );

  		    	if ( service->GetType() == CIptvService::EServiceGroup )

  		    	    {

                    newService->SetType( CVcxNsService::EVcxNsMainGroup );

                    }

  		    	else if ( flags & CIptvService::EReadOnly )

  		    	    {

  		    	    newService->SetType( CVcxNsService::EVcxNsReadOnly );

  		    	    }

  		    	else

  		    	    {

  		    	    newService->SetType( CVcxNsService::EVcxNsEditable ); 

  		    	    }

  		    	if ( EnsureFileExists( service->GetIconPath() ))

  		    	    {

  		    	    newService->SetIconPathL( service->GetIconPath() );

  		    	    }

                newService->SetUpdateTime( service->GetEpgUpdateTimeL() );

                newService->SetUpdateStatus( CVcxNsService::ENotUpdating );

                newService->SetUserNameL( service->GetUserName() );

                newService->SetPasswordL( service->GetPassword() );

                newService->SetDescL( service->GetDesc() );

                newService->SetIsReadOnlyIap( flags & CIptvService::EReadOnlyIaps ? ETrue : EFalse );

                newService->SetAccountMgmtUriL( service->GetAccountManagementUrl() );

                if( flags & CIptvService::EReadOnlyIaps && service->GetIapList().Count() > 0 )

                    {

                    // if readonly, more than one?

                    newService->SetIap( service->GetIapList().IapL(0).iId );

                    }

                iServiceList.AppendL( newService );

                CleanupStack::Pop( newService );

                }

            }

        for ( TInt i = 0; i < services->Count(); i++ )

            {

            service->SetL( services->MdcaPoint(i) );

            flags = service->GetFlags();

            if ( ( service->GetType() == CIptvService::EBrowser )

                    &&  service->GetName().CompareF( KVcxNsVideoDirectory ) == 0 )

                {

                CVcxNsService* videoDirectory = CVcxNsService::NewL();

                CleanupStack::PushL( videoDirectory );

                //Name is localisation string, needs to be handled in UI side.

                videoDirectory->SetServiceId( service->GetId() );

                videoDirectory->SetNameL( service->GetName() );

                videoDirectory->SetCustomUriL( service->GetAddress() );

                videoDirectory->SetIconPathL( service->GetIconPath() );

                videoDirectory->SetType( CVcxNsService::EVcxNsVideoDirectory );

                //Add Video directory item always at the end of the list

                iServiceList.AppendL( videoDirectory );

                CleanupStack::Pop( videoDirectory );

				break; // Allow just one Video Directory

                }

            }

        CleanupStack::PopAndDestroy( service );

        CleanupStack::PopAndDestroy( services );

        }

    return iServiceList;

    }

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

// CVcxNsServiceProvider::GetActiveGroupListL()

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

//

RPointerArray<CVcxNsService>& CVcxNsServiceProvider::GetActiveGroupListL()

    {

    IPTVLOGSTRING_HIGH_LEVEL(

        "UI Engine ## CVcxNsServiceProvider::GetActiveGroupListL()");

    CVcxNsService* service = GetActiveServiceData();

    if( !service )

        {

        User::Leave( KErrNotFound );

        }

    if ( service->Type() == CVcxNsService::EVcxNsMainGroup )

        {

        if ( service->ServiceGroup().Count() <= 0 )

            {

            GetGroupedServicesL( service->GroupId() );

            }

        }

    return service->ServiceGroup();

    }

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

// CVcxNsServiceProvider::OpenServiceL( TInt aIndex )

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

//

void CVcxNsServiceProvider::OpenServiceL( TInt aIndex )

    {

    IPTVLOGSTRING2_LOW_LEVEL("CVcxNsServiceProvider::OpenServiceL (%d)", aIndex );

     if ( iUiEngine.VcAppState() == EStateCustomView ) 

        {

        OpenServiceFromGroupL( aIndex );

        return;

        }

    if( !( aIndex >= 0 && aIndex < iServiceList.Count() ) )

        {

        return;

        }

    if ( iServiceList[aIndex]->Type() == CVcxNsService::EVcxNsVideoDirectory ) 

        {

        OpenToBrowserL( iServiceList[aIndex]->CustomUri() );

        }

    else

        {

        TUint32 serviceToOpen = iServiceList[aIndex]->GetServiceId();

        OpenVideoServiceL( serviceToOpen, aIndex );

        }

    }

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

// CVcxNsServiceProvider::OpenVideoService( TInt aIndex )

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

//

void CVcxNsServiceProvider::OpenVideoServiceL( TUint32 aServiceId, TInt aIndex )

    {

    if( aIndex < 0 && aIndex >= iServiceList.Count() )

        {

        return;

        }

    TBool shouldBeUpdated( EFalse );

    if ( iServiceList[aIndex]->GetUpdateStatus() != CVcxNsService::EUpdateOngoing )

        {

	    if ( iUpdateQueue.Count() > 0 )

	        {

	        IPTVLOGSTRING_LOW_LEVEL("-- Refresh feeds ongoing --");

	        if ( iUpdateQueue.Find( aServiceId ) > KErrNotFound )

	            {

	            shouldBeUpdated = ETrue;

	            }

	        }

	    else if ( iServiceList[aIndex]->Type() == CVcxNsService::EVcxNsMainGroup )

	        {

	        TTime updated( iServiceList[aIndex]->GetUpdateTime() );

	        // See if more than an hour from last update

	        TTime now;

	        now.UniversalTime();

	        TTimeIntervalHours hourInterval( 0 );

	        TInt error( updated.HoursFrom( now, hourInterval ) );

	        if ( error != KErrNone || Abs( hourInterval.Int() ) > 0 )

	            {

	            shouldBeUpdated = ETrue;

	            }

	        }

        }

    CVcxNsContentClientHandler* contentClientHandler = 

        iUiEngine.GetContentClientHandlerL();

    User::LeaveIfNull( contentClientHandler );

    TBool updateAvailable ( EFalse );

    //Check if service update for this available

    CIptvVodContentClient* contentClient = 

        contentClientHandler->GetVodContentClientL( aServiceId );

    User::LeaveIfNull( contentClient );

    CVcxNsService::TServiceUpdateStatus statusOpening =

        iServiceList[aIndex]->GetUpdateStatus();

    if ( !shouldBeUpdated &&  

         !( ( statusOpening == CVcxNsService::EStartingPending || 

            statusOpening == CVcxNsService::EUpdateOngoing ) ) )

        {

        IPTVLOGSTRING_LOW_LEVEL("-- Check update availability --");

        contentClient->UpdateAvailableL( updateAvailable );

        }

    if ( updateAvailable || shouldBeUpdated )

        {

        //Update will start for selected service. 

        // Cancel any update ongoing before opening service:

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

            {

            CVcxNsService::TServiceUpdateStatus status = 

                iServiceList[i]->GetUpdateStatus();

            TUint32 currentlyUpdatedServiceId = iServiceList[i]->GetServiceId();

            if ( status == CVcxNsService::EStartingPending  ||

                 status == CVcxNsService::EUpdateOngoing &&

                 currentlyUpdatedServiceId != aServiceId )

                {

                contentClientHandler->GetVodContentClientL( 

                            currentlyUpdatedServiceId )->CancelUpdate();

                // Update was ongoing, start it whenever possible.

                SetBackToUpdateQueue( currentlyUpdatedServiceId );

                CVcxNsUpdateProgressHandler* progressHandler = iUiEngine.GetProgressHandler();

                progressHandler->Cancel();

                iServiceList[i]->SetUpdateStatus( CVcxNsService::ENotUpdating );

                ServiceUpdated( i );

                break;

                }

             }

        if ( iServiceList[aIndex]->Type() == CVcxNsService::EVcxNsMainGroup

                || iServiceList[aIndex]->Type() == CVcxNsService::EVcxNsEditable

                || iServiceList[aIndex]->Type() == CVcxNsService::EVcxNsReadOnly )

            {

            StartManualUpdateL( aServiceId );

            }

        }

    iUiEngine.SetActiveService( aServiceId );

    if ( iServiceList[aIndex]->Type() == CVcxNsService::EVcxNsMainGroup )

        {

        iUiEngine.SetVcAppState( EStateCustomView );

        }

    else

        {

        RPointerArray<CVcxNsCategory> categorys = iUiEngine.GetCategoryProviderL()->GetCategorysL();

        if( categorys.Count() == 0 )

            {

            iUiEngine.SetActiveCategory( KIptvVodContentCategoryRootId );

            iUiEngine.SetVcAppState( EStateContentView );            

            }

        else if( categorys.Count() == 1 &&

                 categorys[0]->GetCategoryId() == KIptvRssSearchCategoryId )

            {

            iUiEngine.SetActiveCategory( (categorys[0])->GetCategoryId() );

            iUiEngine.SetVcAppState( EStateCategoryView );

            }

        else if( categorys.Count() == 1 )

            {

            iUiEngine.SetActiveCategory( (categorys[0])->GetCategoryId() );

            iUiEngine.SetVcAppState( EStateContentView );

            }

        else

            {

            iUiEngine.SetVcAppState( EStateCategoryView );

            }

        }

    }

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

// CVcxNsServiceProvider::OpenServiceL

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

//

void CVcxNsServiceProvider::OpenServiceL( TUint32 aServiceId )

    {

    TBool found( EFalse );

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

        {

        if ( iServiceList[i]->GetServiceId() == aServiceId )

            {

            OpenServiceL( i );

            found = ETrue;

            break;

            }

        }

    if ( !found )

        {

        //First, remove old services

        RemoveServiceData();

        //Get new list 

        GetSubscribedServicesL();

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

            {

            if ( iServiceList[i]->GetServiceId() == aServiceId )

                {

                OpenServiceL( i );

                break;

                }

            }

        }

    }

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

// CVcxNsServiceProvider::GetCurrentHighlight

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

//

TInt CVcxNsServiceProvider::GetCurrentHighlight()

    {

    CVcxNsService* service = GetActiveServiceData();

    if ( service )

        {

        return service->HighlightCategoryIndex();

        }

    return 0;

    }

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

// CVcxNsServiceProvider::SetCurrentHighlight

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

//

void CVcxNsServiceProvider::SetCurrentHighlight( TInt aIndex )

    {

    CVcxNsService* service = GetActiveServiceData();

    if ( service )

        {

        return service->SetHighlightCategoryIndex( aIndex );

        }

    }

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

// CVcxNsServiceProvider::RemoveServiceL

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

//

void CVcxNsServiceProvider::RemoveServiceL( TInt aIndex )

    {

    CVcxNsService* service = GetServiceData( aIndex );

    if ( service )

        {

        iUiEngine.GetServiceClientHandlerL()->DeleteFeedL( 

                service->GetServiceId() );

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

            {

            if ( iServiceList[i]->GetServiceId() 

                    == service->GetServiceId() )

                {

                CVcxNsService* temp = iServiceList[i];

                delete temp;

                iServiceList.Remove( i );

                iServiceList.Compress();

                }

            }

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

            {

            if ( iServiceObservers[i] )

                {

                iServiceObservers[i]->ServiceRemoved( aIndex, iServiceList );

                }

            }

        }

    }

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

// Get active service data

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

//

CVcxNsService* CVcxNsServiceProvider::GetServiceData( TInt aIndex )

    {

    if ( aIndex >= 0 && 

         iServiceList.Count() > aIndex )

        {

        return iServiceList[ aIndex ];

        }

    return NULL;

    }

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

// CVcxNsServiceProvider::GetServiceDataById()

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

//

CVcxNsService* CVcxNsServiceProvider::GetServiceDataById( TUint32 aServiceId )

    {

    TRAPD( leave, GetSubscribedServicesL() );

    if ( leave != KErrNone )

        {

        return NULL;

        }

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

        {

        if ( ( iServiceList[i])->GetServiceId() == aServiceId )