/*

* Copyright (c) 2008-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:    Handles & propogates UI state change notifications.

*

*/

/**

 * @internal reviewed 24/08/2007 by D Holland

 */

// Class header

#include "glxtv.h"

// External includes

#include <w32std.h>                     // for TWsVisibilityChangedEvent

//  INTERNAL INCLUDES

#include <glxlog.h>                     // for debug logging 

#include <glxtracer.h>                  // for debug logging

#include <glxpanic.h>                   // for Gallery panic codes

#include <glxtvconstants.h>             // for ETvConnectionChanged, TV heights

#include <centralrepository.h>          // for CRepository

#ifdef __MARM

#include <GSServerEngine.h>

#endif

// GLXTVOUT INCLUDES

#include "mglxtvobserver.h"             // for MGlxTvObserver

#include "glxwindowvisibilitymonitor.h" // for CGlxWindowVisibilityMonitor

#include "glxtvconnectionmonitor.h"     // for CGlxTvConnectionMonitor

const TUid KCRUidTvoutSettings = {0x1020730B};

using namespace glxTvOut;

/**

*  CGlxTvOutCenRepMonitor

*  CGlxTv conainted class for observing changes in central 

*					 repository TV aspect Ratio value

* @author Loughlin Spollen

*/

NONSHARABLE_CLASS( CGlxTv::CGlxTvOutCenRepMonitor )

	                      : public CActive

	{

	public:  // Constructors and destructor

	    /**

	    * Symbian Constructor.

	    * @param The TV Observer

	    * @param The central repository

	    * @return constructed object

	    */

	    static CGlxTvOutCenRepMonitor* NewL(MGlxTvObserver& aTvObserver,

	                                    CRepository& aRepository);

	    /**

	    * Destructor.

	    */

	    ~CGlxTvOutCenRepMonitor();

	private: 

	    /**

	    * C++ constructor.

	    * @param The TV Observer

	    * @param The central repository

	    * @return constructed object

	    */

	    CGlxTvOutCenRepMonitor(MGlxTvObserver& aTvObserver,

	                            CRepository& aRepository);

	    /**

	    * 2nd phase constructor

	    */

	    void ConstructL();

	protected: // from CActive

	    /**

	    * @ref CActive::RunL

	    */

	    void RunL();

	    /**

	    * @ref CActive::DoCancel

	    */

	    void DoCancel();

	    /**

	    * @ref CActive::RunError

	    */

	    TInt RunError(TInt aError);

	private:

	    // Not Owned: the Glx TV observer

	    MGlxTvObserver& iTvObserver;

		// Not Owned: the central repository API

	    CRepository& iRepository;       

	    TUint iSettingsTVAspectRatio;

	    // the central repository identifier

	    TUid iRepositoryUid;

	}; 

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

// Two-phased constructor.

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

CGlxTv::CGlxTvOutCenRepMonitor* CGlxTv::CGlxTvOutCenRepMonitor::NewL

										        ( MGlxTvObserver& aTvObserver,

	                                                CRepository& aRepository )

    {

    TRACER("CGlxTv::CGlxTvOutCenRepMonitor::NewL()");

    CGlxTvOutCenRepMonitor* self 

                = new(ELeave) CGlxTvOutCenRepMonitor( aTvObserver, aRepository );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ constructor.

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

inline CGlxTv::CGlxTvOutCenRepMonitor::CGlxTvOutCenRepMonitor

                                                ( MGlxTvObserver& aTvObserver,

	                                              CRepository& aRepository )

                    				 : CActive( EPriorityStandard ),

                    				   iTvObserver ( aTvObserver ),

                 				       iRepository( aRepository )

    {

    TRACER("CGlxTv::CGlxTvOutCenRepMonitor::CGlxTvOutCenRepMonitor()");

    }

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

// Symbian 2nd phase constructor 

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

void CGlxTv::CGlxTvOutCenRepMonitor::ConstructL()

    {

	TRACER("CGlxTv::CGlxTvOutCenRepMonitor::ConstructL");

    CActiveScheduler::Add( this );

#ifdef __MARM

    CGSServerEngine* gsServerEngine= CGSServerEngine::NewLC();

    iSettingsTVAspectRatio = gsServerEngine->AspectRatioL();

    CleanupStack::Pop(gsServerEngine);

#else

    iSettingsTVAspectRatio = 0;

#endif

    }

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

// Destructor

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

CGlxTv::CGlxTvOutCenRepMonitor::~CGlxTvOutCenRepMonitor()

    {

    TRACER("CGlxTv::~CGlxTvOutCenRepMonitor()");

    Cancel();

    }

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

// CGlxTvOutCenRepMonitor::RunL

// From class CActive.

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

void CGlxTv::CGlxTvOutCenRepMonitor::RunL()

    {

    TRACER("CGlxTv::CGlxTvOutCenRepMonitor::RunL");

    // Check for errors

    User::LeaveIfError( iStatus.Int() );

    GLX_LOG_INFO("CGlxTvOutCenRepMonitor - RunL completed with Err Code"); 

    User::LeaveIfError( iRepository.NotifyRequest( iSettingsTVAspectRatio, iStatus ) );

    if (!IsActive())

        {

        SetActive();

        iTvObserver.HandleTvStatusChangedL( ETvConnectionChanged );

        }

    }

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

// CGlxTvOutCenRepMonitor::DoCancel

// From class CActive.

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

void CGlxTv::CGlxTvOutCenRepMonitor::DoCancel()

    {

    TRACER("CGlxTv::CGlxTvOutCenRepMonitor::DoCancel()");

    iRepository.NotifyCancel( iSettingsTVAspectRatio );  

    }

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

// CGlxTvOutCenRepMonitor::RunError

// From class CActive.

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

//

TInt CGlxTv::CGlxTvOutCenRepMonitor::RunError( TInt /*aError*/ )

    {

    TRACER("CGlxTv::CGlxTvOutCenRepMonitor::RunError()");

    return KErrNone;

    }

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

// Return new object

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

//

EXPORT_C CGlxTv* CGlxTv::NewL( MGlxTvObserver& aTvObserver ) 

    {

    TRACER("CGlxTv::NewL()");

    CGlxTv* self = new (ELeave) CGlxTv( aTvObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

EXPORT_C CGlxTv::~CGlxTv()

    {

    TRACER("CGlxTv::~CGlxTv()");

    StopMonitoringEnvironment();

    delete iTvConnectionMonitor;

    }

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

// Default C++ constructor

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

//

CGlxTv::CGlxTv( MGlxTvObserver& aTvObserver ) : iTvObserver( aTvObserver ),

                                                iAspectRatio( KErrUnknown )

    {

    TRACER("CGlxTv::CGlxTv()");

    }

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

// Symbian second phase constructor

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

//

void CGlxTv::ConstructL()

    {

    TRACER("CGlxTv::ConstructL()");

    // Don't create the visibility monitor until the TV Out cable is connected

    // Owned: The TV connection monitor

    iTvConnectionMonitor = CGlxTvConnectionMonitor::NewL( *this );

    if ( iTvConnectionMonitor->IsConnected() )

        {

        // Start monitoring the environment for changes

        MonitorEnvironmentL();

        // Calculate the TV Out screen buffer size

        CalcTvScreenSzL();

        }

    }

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

// returns the TV screen size 

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

//

EXPORT_C TSize CGlxTv::ScreenSizeL() const

    {

    TRACER("CGlxTv::ScreenSizeL()");

    return iSzInPixels;

    }

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

// Is the analog TV Connected

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

//

EXPORT_C TBool CGlxTv::IsConnected() const

    {

    TRACER("CGlxTv::IsConnected()");

    return iTvConnectionMonitor->IsConnected();

    }

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

// Is the HDMI TV Connected

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

//

EXPORT_C TBool CGlxTv::IsHDMIConnected() const

    {

    TRACER("CGlxTv::IsHDMIConnected()");

    return iTvConnectionMonitor->IsHDMIConnected();

    }

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

// Is the TV widescreen

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

//

EXPORT_C TBool CGlxTv::IsWidescreen() const

    {

    TRACER("CGlxTv::IsWidescreen()");

    return iAspectRatio == KGlxTvAspectWide;

    }

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

// From class MGlxWindowVisibilityObserver.

// Called when window becomes fully visible or not visible.

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

//

void CGlxTv::HandleWindowVisibilityChangedL( TTvChangeType aChangeType )

    {

    TRACER("CGlxTv::HandleWindowVisibilityChangedL()");

    iTvObserver.HandleTvStatusChangedL( aChangeType );

    }

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

// From class MGlxTvConnectionObserver.

// Called when TV connection state changes

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

//

void CGlxTv::HandleTvConnectionStatusChangedL(TTvChangeType aChangeType)

    {

	TRACER("CGlxTv::HandleTvConnectionStatusChangedL()");

	if (iTvConnectionMonitor->IsConnected())

		{

		// Start monitoring the environment for changes

		MonitorEnvironmentL();

		// Calculate the TV Out screen buffer

		CalcTvScreenSzL();

		}

	else

		{

		StopMonitoringEnvironment();

		}

	iTvObserver.HandleTvStatusChangedL(aChangeType);

	}

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

// Retrieve the TV display aspect ratio

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

//

void CGlxTv::CalcTvScreenSzL()

    {

    TRACER("CGlxTv::CalcTvScreenSzL()");

    // Retrieve the aspect ratio and the settings info from CenRep        

    iAspectRatio  = KErrNotFound;

#ifdef __MARM

    CGSServerEngine* gsServerEngine = CGSServerEngine::NewLC();

    iAspectRatio = gsServerEngine->AspectRatioL();

    CleanupStack::Pop(gsServerEngine);

	User::LeaveIfError( iAspectRatio );

#else

	iAspectRatio = 0;

#endif

    // note: Constants are defined in the GSServerEngine.cpp and not exported

    // they are defined locally in glxtvconstants.h

    switch( iAspectRatio )

        {

        case KGlxTvAspectWide:

            {

            iSzInPixels = TSize ( KGlxTvOutWidthWide, KGlxTvOutHeightWide) ;

            break;

            }

        case KGlxTvAspectNormal:

            {

            iSzInPixels = TSize ( KGlxTvOutWidth, KGlxTvOutHeight );

            break;

            }

        default:

            {

            User::Leave(KErrUnknown);

            }

        }

	}

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

// From class MonitorEnvironmentL.

// Called when TV connection state changes to connected

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

//

void CGlxTv::MonitorEnvironmentL()

    {

    TRACER("CGlxTv::MonitorEnvironmentL()");

    // Instantiate the central repository

    if (!iCenRep)

        {

        // The Uid is hardcoded here as the hrh file giving us the Uid has been depricated and 

        // moved to a private folder

        iCenRep = CRepository::NewL( KCRUidTvoutSettings );

        }

    // Monitor changes to the aspect ratio in the central repository

    if (!iTvDisplayAspectRatioMonitor)    

        {

        iTvDisplayAspectRatioMonitor 

                    = CGlxTvOutCenRepMonitor::NewL( iTvObserver, *iCenRep );

        }

    // create window visibility monitoring object

    if ( !iWindowVisibilityMonitor )

        {

        iWindowVisibilityMonitor = 

                                CGlxWindowVisibilityMonitor::NewL( *this );

        }

    }

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

// StopMonitoringEnvironment().

// Called when TV connection state changes to disconnected

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

//

void CGlxTv::StopMonitoringEnvironment()

    {

    TRACER("CGlxTv::StopMonitoringEnvironment()");

    delete iTvDisplayAspectRatioMonitor; // destroy before iCenRep - must cancel 

    iTvDisplayAspectRatioMonitor = NULL; // outstanding requests

    if (iWindowVisibilityMonitor)

        {

        iWindowVisibilityMonitor->Close();

        }

    delete iWindowVisibilityMonitor;

    iWindowVisibilityMonitor = NULL;

    delete iCenRep;

    iCenRep = NULL;

    }

// End of file