/*
* Copyright (c) 2009 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: 
*
*/




#include <bldvariant.hrh>
#include "IptvDebug.h"
#include "CIptvUtil.h"
#include <ipvideo/vcxconnectionutility.h>

#include "CIptvVodContentClient.h"
#include "vcxnscontentclienthandler.h"
#include "vcxnsuiengine.h"
#include "vcxnseventrouter.h"
#include "vcxnsserviceprovider.h"
#include "vcxnsservice.h"

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::CVcxNsContentClientHandler()
// -----------------------------------------------------------------------------
//
CVcxNsContentClientHandler::CVcxNsContentClientHandler( 
    CVcxNsUiEngine& aUiEngine,
    CVcxConnectionUtility& aConnUtil )
:   iUiEngine( aUiEngine ),
    iConnUtil ( aConnUtil )
    {
    }

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::NewL()
// -----------------------------------------------------------------------------
//
CVcxNsContentClientHandler* CVcxNsContentClientHandler::NewL( 
    CVcxNsUiEngine& aUiEngine,
    CVcxConnectionUtility& aConnUtil )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsContentClientHandler::NewL()");
    
    CVcxNsContentClientHandler* self = 
        new (ELeave) CVcxNsContentClientHandler( aUiEngine, aConnUtil );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    
    return self;    
    }
    
// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::ConstructL()
// -----------------------------------------------------------------------------
//
void CVcxNsContentClientHandler::ConstructL()
    {
    iConnUtil.RegisterObserverL( this );	
    }

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::~CVcxNsContentClientHandler()
// -----------------------------------------------------------------------------
//
CVcxNsContentClientHandler::~CVcxNsContentClientHandler()
    {
    iVodContentClients.ResetAndDestroy(); 
    
    iVodContentClientIds.Reset();
   
    iIapAsked.Reset();
    
    iConnUtil.RemoveObserver( this );
    }

// -----------------------------------------------------------------------------
// CVcxNsContentProvider::GetVodContentClientL()
// -----------------------------------------------------------------------------
//
CIptvVodContentClient* CVcxNsContentClientHandler::GetVodContentClientL( TUint32 aServiceId )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsContentClientHandler::GetVodContentClientL()");

    CIptvVodContentClient* vodContentClient = NULL;

    // Check if content client for this service ID already exists.
    for ( TInt i = 0; i < iVodContentClientIds.Count(); i++ )
        {
        if ( iVodContentClientIds[i] == aServiceId )
            {
            vodContentClient = iVodContentClients[i];
            break;
            }
        }

    // Create client if necessary.
    if ( !vodContentClient )
        {
        vodContentClient = CIptvVodContentClient::NewL( aServiceId, *this );
       
        iVodContentClients.AppendL( vodContentClient );
        iVodContentClientIds.AppendL( aServiceId );
        //Set this to ETrue by default - if user cancels in connection
        //query, then set to EFalse
        iIapAsked.AppendL( ETrue );
        }

    return vodContentClient;
    }

// -----------------------------------------------------------------------------
// CVcxNsContentProvider::UpdateEcgL()
// -----------------------------------------------------------------------------
//
TInt CVcxNsContentClientHandler::UpdateEcgL( TUint32 aServiceId )
    {
    CIptvVodContentClient* client = GetVodContentClientL( aServiceId );
    
    if ( !( IapAsked( aServiceId ) ) )
        {
        HandleEpgManagerMsgL( KIptvErrorVodNoIap, 0, aServiceId );
        }
        
    return client->UpdateEcgL();
    }

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::StoreMpxIdToEcgDbL()
// -----------------------------------------------------------------------------
//
void CVcxNsContentClientHandler::StoreMpxIdToEcgDbL( TUint32 aServiceId,
                                                     TUint32 aContentId,
                                                     TUint32 aCaIndex,
                                                     TUint32 aMpxId )
    {
    IPTVLOGSTRING_LOW_LEVEL("CVcxNsContentClientHandler::StoreMpxIdToEcgDbL");

    GetVodContentClientL(aServiceId)->SetMpxIdL( aContentId, aCaIndex, aMpxId );
    }

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::StoreLastPlayPosL()
// -----------------------------------------------------------------------------
//
void CVcxNsContentClientHandler::StoreLastPlayPosL( TUint32 aServiceId,
                                                    TUint32 aContentId,
                                                    TUint32 aCaIndex,
                                                    TReal32 aPos )
    {
    TUint32 pos( aPos );
    
    IPTVLOGSTRING2_LOW_LEVEL("CVcxNsContentClientHandler::StoreLastPlayPosL ( %d )", pos );

    GetVodContentClientL(aServiceId)->SetLastPositionL( aContentId, aCaIndex, pos );
    }

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::HandleEpgManagerMsgL()
// -----------------------------------------------------------------------------
//
void CVcxNsContentClientHandler::HandleEpgManagerMsgL( 
    TInt aMsg, 
    TInt aInfo, 
    TIptvServiceId aServiceId )
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsContentClientHandler::HandleEpgManagerMsgL()");

    TInt error( KErrNone );
    
    if( aMsg == KIptvErrorVodNoIap || aMsg == KIptvErrorRssSearchNoIap &&
          ( iUiEngine.VcAppState() == EStateServiceView ||
            iUiEngine.VcAppState() == EStateCategoryView ||
            iUiEngine.VcAppState() == EStateContentView ||
            iUiEngine.VcAppState() == EStateCustomView ) )
        {
        TUint32 iap( 0 );
        error = iConnUtil.GetIap( iap, EFalse );

        if ( error == KErrNone ) 
            {
            GetVodContentClientL( aServiceId )->SetIapL( iap );
            SetIapAsked( aServiceId, ETrue );
            }
        else
            {
            GetVodContentClientL( aServiceId )->CancelUpdate();
            SetIapAsked( aServiceId, EFalse );
            
            if ( iUiEngine.ServiceProvider() )
                {
                CVcxNsService* service = NULL;
                
                service = iUiEngine.ServiceProvider()->GetServiceDataById( aServiceId );
                
				if ( service )
                    {
                    service->SetUpdateStatus( CVcxNsService::ENotUpdating );
                    }
                
                iUiEngine.ServiceProvider()->CancelUpdateQueue();
                }
            }
        }
    if( error == KErrNone )
        {
        iUiEngine.GetEventRouter()->HandleEpgManagerMsgL( aMsg, aInfo, aServiceId );
        }
    }

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::RequestIsRoamingAllowedL()
// -----------------------------------------------------------------------------
//
TBool CVcxNsContentClientHandler::RequestIsRoamingAllowedL()
    {
    // we accept roaming every time and let the
    // update decide whether to use new iap or not
    // when new iap is available
    return ETrue;
    }
    
// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::IapChangedL()
// -----------------------------------------------------------------------------
//
void CVcxNsContentClientHandler::IapChangedL()
    {
    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsContentClientHandler::IapChangedL() enter");
 
    // Find out if any of the services is currently updating to make sure
    // GetIap() is only called when really needed to avoid unnecessary
    // IAP selection dialog.
    RPointerArray<CVcxNsService> servicesList =
        iUiEngine.GetServiceProviderL()->GetSubscribedServicesL();

    TBool updateOngoing( EFalse );
    const TInt serviceCount = servicesList.Count();

    IPTVLOGSTRING2_HIGH_LEVEL("UI Engine ## CVcxNsContentClientHandler::IapChangedL() service count: %d", serviceCount );

    for ( TInt i=0; i < serviceCount && !updateOngoing; i++ )
        {
        if ( servicesList[i]->GetUpdateStatus() == CVcxNsService::EUpdateOngoing )
            {
            IPTVLOGSTRING2_HIGH_LEVEL("UI Engine ## CVcxNsContentClientHandler::IapChangedL() service index %d is updating", i );
            updateOngoing = ETrue;
            }
        }

    IPTVLOGSTRING2_HIGH_LEVEL("UI Engine ## CVcxNsContentClientHandler::IapChangedL() updateOngoing: %d", updateOngoing );

    if ( updateOngoing )
        {
        // connectionutility notifies that iap has changed.
        // get new iap and save it to all services.
        // update server decides whether to use new iap or not
        TInt count( iVodContentClients.Count() );
        TUint32 iap( 0 );
        TInt err =  iConnUtil.GetIap( iap, EFalse ); 
        if( err != KErrNone )
            {
            for ( TInt i = 0; i < count; i++ )
                {
                ( iVodContentClients[i] )->SetIapL( iap );        
                }    
            }
        }

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsContentClientHandler::IapChangedL() return");
    }

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::IapAsked
// -----------------------------------------------------------------------------
//
TBool CVcxNsContentClientHandler::IapAsked( TUint32 aServiceId )
    {
    for ( TInt i = 0; i < iVodContentClientIds.Count(); i++ )
        {
        if ( iVodContentClientIds[i] == aServiceId )
            {
            return iIapAsked[i];
            }
        }    
    
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CVcxNsContentClientHandler::SetIapAsked
// -----------------------------------------------------------------------------
//
void CVcxNsContentClientHandler::SetIapAsked( TUint32 aServiceId, TBool aSet )
    {
    for ( TInt i = 0; i < iVodContentClientIds.Count(); i++ )
        {
        if ( iVodContentClientIds[i] == aServiceId 
             && iIapAsked.Count() > i )
            {
            iIapAsked[i] = aSet;
            }
        }    
    }