/*

* 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 "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 "Connected" state of HDMI Cable Status FSM.

*

*/

#include <e32def.h>

#include <e32cmn.h>

#include "pdeconstants.h"

#include "accessorycontrolif.h"

#include "hdmicablestatusfsm.h"

#include "hdmicablestateconnected.h"

#include "tvoutconfigforhdmi.h"

#include "edidhandler.h"

#include "trace.h"

#include <centralrepository.h>

#include <accessoriescrkeys.h>

#include <tvoutconfig.h>

// ======== LOCAL FUNCTIONS ========

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

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

//Symbian two-phased constructor

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

//

CHDMICableStateConnected* CHDMICableStateConnected::NewL( 

        CTVOutConfigForHDMI& aTVOutConfigForCableConnect,

        CEDIDHandler& aEDIDHandler,

        CAccessoryControlIf& aAccessoryControlIf,

        CHDMICableStatusFSM&  aHDMICableStatusFSM )

    {

    FUNC_LOG;

    CHDMICableStateConnected* self = new ( ELeave ) CHDMICableStateConnected(            

            aTVOutConfigForCableConnect,

            aEDIDHandler, aAccessoryControlIf,

            aHDMICableStatusFSM );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CHDMICableStateConnected::~CHDMICableStateConnected()

    {

    FUNC_LOG;

    if ( iTVOutConfigForCopyProtect )

        {

        iTVOutConfigForCopyProtect->Cancel();        

        delete iTVOutConfigForCopyProtect;

        }

    if ( iTVOutConfigForSettingChanges )

        {

        iTVOutConfigForSettingChanges->Cancel();

        delete iTVOutConfigForSettingChanges;

        }

    if ( iCRWatchForVOverScan )

        {

        iCRWatchForVOverScan->Cancel();

        delete iCRWatchForVOverScan;        

        }

    }

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

// From MCentralRepositoryObserver.

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

//

void CHDMICableStateConnected::CentRepKeyChanged(

        TUid    aRepositoryId,

        TUint32 aId )

    {

    FUNC_LOG;

    if ( KCRUidTvoutSettings == aRepositoryId )

        {

        if ( KSettingsTvoutVerticalOverscan == aId  )

            {            

			INFO("Cenrep Value Changed");

			if( iEDIDHandler.UpdateOverscanValues() )

				{

				INFO( "There is a real change" );

            	Input( EPDEIfCentralRepositoryWatch, EPDEIfCentralRepositoryWatchEventKeyChanged );

				}

            }

        else

            {

            INFO_1("Unexpected CR key ID, aId 0x%x", aId );            

            }       

        }

    else

        {

        INFO_1("Unexpected Central Repository ID, aRepositoryId 0x%x", aRepositoryId);

        }

    }

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

// From MCentralRepositoryObserver.

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

//

void CHDMICableStateConnected::CentRepGetKeyValueFailed(

        TUid    aRepositoryId,

        TUint32 aId,

        TInt    aError )

    {

    FUNC_LOG;

    // Make use of aError argument top get rid of compiler warning.

    TInt error( aError );

    if ( ( KCRUidTvoutSettings == aRepositoryId ) && ( KErrNone != error ) )

        {

        if ( KSettingsTvoutVerticalOverscan == aId  )

            {

            INFO_1(" Getting KSettingsTvoutVerticalOverscan from CR failed, aError %d", error );                                    

            }

        else

            {

            INFO_1("Unexpected CR key ID, aId 0x%x", aId );            

            }       

        }

    else

        {

        INFO_1("Unexpected Central Repository ID, aRepositoryId 0x%x", aRepositoryId);

        }    

    }

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

// From MFSMState.

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

//

void CHDMICableStateConnected::Enter( )

    {

    FUNC_LOG;

    TInt retVal( KErrNone );

	// Get the current overscan value

	iEDIDHandler.UpdateOverscanValues();

	iEDIDHandler.GetCurrentOverscanValue( iHOverscanValue, iVOverscanValue );

    iCopyProtectListenFailCounter.iCount = 0;

    iTVOutConfigForCopyProtect->ResetLatestRecordedCopyProtectionStatus();

    retVal = iEDIDHandler.FetchEDIDData();

    if ( KErrNone != retVal )

        {

        INFO( "Going to state <Rejected> since iEDIDHandler.FetchEDIDData() failed!" );        

        iHDMICableStatusFSM.Transit( EHDMICableStateRejected );         

        }

    else

        {

        iSubState = ESubStateFechEdidData;

        }

    }

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

// From MFSMState.

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

//

void CHDMICableStateConnected::Input(

        TFSMInterfaceId aInterfaceId ,

        TFSMEventId aEvent )

    {

    FUNC_LOG;

    switch ( iSubState )

    {

    case ESubStateFechEdidData:

        {

        SubStateFetchEdidDataInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateStartListenSettingsChanges:

        {

        CHDMICableStateConnected::SubStateStartListenConfigChangesInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateEnable:

        {

        SubStateEnableInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateResettingEnable:

        {

        SubStateResettingEnableInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateIdlingDisable:

        {

        SubStateIdlingDisableInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateResettingDisable:

        {

        SubStateResettingDisableInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateRejectingDisable:

        {

        SubStateRejectingDisableInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateConnectAccessory:

        {

        SubStateConnectAccessoryInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateIdlingDisconnectAccessory:

        {

        SubStateIdlingDisconnectAccessoryInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateRejectingDisconnectAccessory:

        {

        SubStateRejectingDisconnectAccessoryInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateConnected:

        {

        SubStateConnectedInput( aInterfaceId, aEvent );

        break;

        }

    case ESubStateWaitForSettingsChanged:

        {

        SubStateWaitForSettingsChangedInput( aInterfaceId, aEvent );

        break;

        }

    default:

        {

        INFO_1( "Unexpected Event Id: %i", aEvent );        

        INFO_1( "From interface Id: %i", aInterfaceId );        

        break;

        }

    }

    }

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

// From MFSMState.

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

//

TFSMState CHDMICableStateConnected::Id()

    {

    FUNC_LOG;

    TFSMState tempStateId( EHDMICableStateConnected );

    INFO_1( "State's id: %i", tempStateId );

    return tempStateId;

    }

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

// From MFSMState.

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

//

TPtrC CHDMICableStateConnected::Name()

    {

    FUNC_LOG;

    TPtrC temp( KHDMICableStateConnected );

    INFO_1( "State's name: %s", temp.Ptr() );

    return temp;

    }

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

// From MFSMState.

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

//

TFSMState CHDMICableStateConnected::SubId()

    {

    FUNC_LOG;

    TFSMState tempSubstateId( iSubState );

    INFO_1( "Substate's id: %i", tempSubstateId );

    return tempSubstateId;

    }

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

// ListenCopyProtectionStatusChanges.

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

//

void CHDMICableStateConnected::ListenCopyProtectionStatusChanges()

    {

    FUNC_LOG;

    TCopyProtctListenRetValues retStruct = iTVOutConfigForCopyProtect->ListenCopyProtectionIfNoMissedEvents();

    if ( EIfTVOutConfigEventSetCopyProtectStatusChanged == retStruct.iFSMEventId )

        {

        // Copy Protection status changed while not listening

        Input( EPDEIfTVOutConfig, EIfTVOutConfigEventSetCopyProtectStatusChanged );                       

        }

    else if ( EIfTVOutConfigEventCopyProtectionListenFailed == retStruct.iFSMEventId )

        {

        iHDMICableStatusFSM.CopyProtectionListenFailed( retStruct.iError );

        }

    }

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

// SubStateFetchEdidDataInput

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

//

void CHDMICableStateConnected::SubStateFetchEdidDataInput(

        TFSMInterfaceId aInterfaceId ,

        TFSMEventId aEvent )

    {

    FUNC_LOG;

    switch ( aInterfaceId )

    {

    case EPDEIfEDIDHandler:

        {

        INFO( "Interface: EPDEIfEDIDHandler" );

        if ( EPDEIfEDIDHandlerEventEdidDataFetched == aEvent )

            {

            INFO( "Event: EPDEIfEDIDHandlerEventEDdidDataFetched" );        

            if ( !iTVOutConfigForHDMI.GetTvOutConfig()->HdmiCableConnected() )

                {

                INFO( "Retreating back to <Idle> since cable was disconnected while not listening!" );        

                iHDMICableStatusFSM.Transit( EHDMICableStateIdle );         

                }

            else

                {

                TFSMEventId event = iTVOutConfigForHDMI.ListenHDMICableStatusIfNoMissedEvents();

                if ( EIfTVOutConfigEventCableDisconnected == event )

                    {

                    INFO( "Retreating back to <Idle> since cable was disconnected while not listening!" );        

                    iHDMICableStatusFSM.Transit( EHDMICableStateIdle );         

                    }

                else

                    {

                    iTVOutConfigForSettingChanges->ListenSettingsChanges();

                    iSubState = ESubStateStartListenSettingsChanges;

                    }

                }

            }

        else if ( EPDEIfEDIDHandlerEventEdidDataFetchFailed == aEvent )

            {

            INFO( "Event: EPDEIfEDIDHandlerEventEDdidDataFetchFailed" );        

            INFO( "Going to state <Rejected>" );        

            iHDMICableStatusFSM.Transit( EHDMICableStateRejected );                     

             }

        else

            {

            INFO_1( "Unknown/unexpected Event Id: %i", aEvent );        

            }

        break;

        }

    default:

        {

        INFO_1( "Event received from unknown/unexpected interface Id: %i", aInterfaceId );        

        break;

        }

    }

    }

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

// SubStateStartListenConfigChangesInput

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

//

void CHDMICableStateConnected::SubStateStartListenConfigChangesInput(

        TFSMInterfaceId aInterfaceId ,

        TFSMEventId aEvent )

    {

    FUNC_LOG;

    switch ( aInterfaceId )

    {

        case EPDEIfTVOutConfig:

            {       

            INFO( "Interface: TPDEIfTVOutConfig" );        

            if ( EIfTVOutConfigEventSettingsChangesListenStarted == aEvent )

                {

                INFO( "Event: EIfTVOutConfigEventSettingsChangesListenStarted" );        

                if ( !iTVOutConfigForHDMI.GetTvOutConfig()->HdmiCableConnected() )

                    {

                    INFO( "Retreating back to <Idle> since cable was disconnected while not listening!" );        

                    iTVOutConfigForSettingChanges->Cancel();

                    iHDMICableStatusFSM.Transit( EHDMICableStateIdle );         

                    }

                else

                    {

                    TInt retVal = iEDIDHandler.SetVideoParameters();

                    if ( KErrNone != retVal )

                        {

                        INFO( "Going to state <Rejected> since video parameter setting failed!" );        

                        iTVOutConfigForSettingChanges->Cancel();

                        iHDMICableStatusFSM.Transit( EHDMICableStateRejected );         

                        }

                    else

                        {

						// Update the current overscan value

						iEDIDHandler.GetCurrentOverscanValue( iHOverscanValue, iVOverscanValue );

                        TFSMEventId event = iTVOutConfigForHDMI.ListenHDMICableStatusIfNoMissedEvents();

                        if ( EIfTVOutConfigEventCableDisconnected == event )

                            {

                            INFO( "Retreating back to <Idle> since cable was disconnected while not listening!" );        

                            iTVOutConfigForSettingChanges->Cancel();

                            iHDMICableStatusFSM.Transit( EHDMICableStateIdle );         

                            }

                        else

                            {

                            iSubState = ESubStateWaitForSettingsChanged;

                            }

                        }         

                    }

                }

            else if ( EIfTVOutConfigEventSettingsChangesListenFailed == aEvent )

                {

                INFO( "Event: EIfTVOutConfigEventSettingsChangesListenFailed" );        

                INFO( "Going to state <Rejected> since TV Out Settings Change listening failed!" );        

                iHDMICableStatusFSM.Transit( EHDMICableStateRejected );         

                }

            else

                {

                INFO_1( "Unknown/unexpected Event Id: %i", aEvent );        

                }

            break;

            }

    default:

        {

        INFO_1( "Event received from unknown/unexpected interface Id: %i", aInterfaceId );        

        break;

        }

    }

    }

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

// SubStateEnableInput

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

//

void CHDMICableStateConnected::SubStateEnableInput(

        TFSMInterfaceId aInterfaceId ,

        TFSMEventId aEvent )

    {

    FUNC_LOG;

    switch ( aInterfaceId )

    {

    case EPDEIfTVOutConfig:

        {       

        INFO( "Interface: TPDEIfTVOutConfig" );        

        if ( EIfTVOutConfigEventEnabled == aEvent )

            {

            INFO( "Event: EIfTVOutConfigEventEnabled" );        

            if ( !iTVOutConfigForHDMI.GetTvOutConfig()->HdmiCableConnected() )

                {

                INFO( "Disabling since cable was disconnected while not listening!" );        

                iSubState = ESubStateIdlingDisable;

                iTVOutConfigForHDMI.Disable();            

                }

            else

                {

                TInt retVal( KErrNone );

                TBool copyProtectStatus = iTVOutConfigForCopyProtect->GetTvOutConfig()->CopyProtectionStatus();

                TRAP( retVal, iAccessoryControlIf.ConnectAccessoryL( copyProtectStatus ) );

                if ( KErrNone != retVal )

                    {

                    INFO_1( "Rejecting since CAccessoryControlIf::ConnectAccessoryL() failed, error code %i", retVal );        

                    iSubState = ESubStateRejectingDisable;

                     iTVOutConfigForHDMI.Disable();            

                    }

                else

                    {

                    iSubState = ESubStateConnectAccessory;

                    }

                }

            }

        else if ( EIfTVOutConfigEventEnableFailed == aEvent )

            {

            INFO( "Event: EIfTVOutConfigEventEnableFailed" );        

            INFO( "Going to state <Rejected> since TV Out Enabling failed!" );        

            iHDMICableStatusFSM.Transit( EHDMICableStateRejected );         

            }

        else

            {

            INFO_1( "Unknown/unexpected Event Id: %i", aEvent );        

            }

        break;

        }

    default:

        {

        INFO_1( "Event received from unknown/unexpected interface Id: %i", aInterfaceId );        

        break;

        }

    }    

    }

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

// SubStateResettingEnableInput

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

//

void CHDMICableStateConnected::SubStateResettingEnableInput(

        TFSMInterfaceId aInterfaceId ,

        TFSMEventId aEvent )

    {

    FUNC_LOG;

    switch ( aInterfaceId )

    {

    case EPDEIfTVOutConfig:

        {       

        INFO( "Interface: TPDEIfTVOutConfig" );        

        if ( EIfTVOutConfigEventEnabled == aEvent )

            {

            INFO( "Event: EIfTVOutConfigEventEnabled" );        

            TFSMEventId event = iTVOutConfigForHDMI.ListenHDMICableStatusIfNoMissedEvents();

            if ( EIfTVOutConfigEventCableDisconnected == event )

                {