/*

#include <w32std.h>

#include <alf/alfutil.h>

#include <glxtracer.h>

#include <glxlog.h>

#include "glxtv.h"                      // for CGlxTv

#include "glxhdmicontainer.h"

#include "glxhdmisurfaceupdater.h"

#include "glxhdmicontroller.h"

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

// NewLC

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

    {

    TRACER("CGlxHdmiController* CGlxHdmiController::NewL()");

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// destructor 

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

EXPORT_C CGlxHdmiController::~CGlxHdmiController()

    {

    TRACER("CGlxHdmiController::~CGlxHdmiController()");

    DestroySurfaceUpdater();

    DestroyContainer();

    delete iStoredImagePath;

    if (iFsBitmap)

        {

        delete iFsBitmap;

        }

        delete iGlxTvOut;

    }

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

// Setting an Image Path 

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

    {

    TRACER("CGlxHdmiController::SetImageL()");

    if (aFsBitmap == NULL || !aImageFile.Length())

        {

        GLX_LOG_INFO("CGlxHdmiController::SetImageL() - NULL Uri");

        return;

        }

    if (aStore)

        {

        iIsImageSupported = ETrue;

        }

    if (iGlxTvOut->IsHDMIConnected())

        {

        GLX_LOG_INFO("CGlxHdmiController::SetImageL() - 2");

        // do not close the surface , use the same surface instead.

        // Call a function to pass imagefile

        if (!iHdmiContainer)

        if (!iSurfaceUpdater)

            {

            // This case would come when surface updater is not created at the first instance and also

            // it satisfies the 720p condition                

            }

        else

            {

            GLX_LOG_INFO("CGlxHdmiController::SetImageL() - 3");

            }

        iHdmiContainer->DrawNow();

        }

    }

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

// ItemNotSupported 

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

EXPORT_C void CGlxHdmiController::ItemNotSupported()

    {

    TRACER("CGlxHdmiController::IsVideo()");

    iIsImageSupported = EFalse;

    if (iGlxTvOut->IsHDMIConnected())

        {

        DestroySurfaceUpdater();

        }

    }

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

// ActivateZoom 

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

EXPORT_C void CGlxHdmiController::ActivateZoom(TBool aAutoZoomOut)

    {

    TRACER("CGlxHdmiController::ActivateZoom()");

    if (iGlxTvOut->IsHDMIConnected() && iSurfaceUpdater)

        {

        iSurfaceUpdater->ActivateZoom(aAutoZoomOut);

        }

    }

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

// DeactivateZoom 

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

EXPORT_C void CGlxHdmiController::DeactivateZoom()

    {

    TRACER("CGlxHdmiController::DeactivateZoom()");

    if (iGlxTvOut->IsHDMIConnected() && iSurfaceUpdater)

        {

        iSurfaceUpdater->DeactivateZoom();

        }

    }

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

// ShiftToCloningMode 

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

EXPORT_C void CGlxHdmiController::ShiftToCloningMode()

    {

    TRACER("CGlxHdmiController::ShiftToCloningMode()");

    iIsPhotosInForeground = EFalse;

    // Shift to cloning only if HDMI is connected and surfaceupdater available.

    if (iGlxTvOut->IsHDMIConnected() && iSurfaceUpdater)

        {

        iSurfaceUpdater->ShiftToCloningMode();

        }

    }

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

// ShiftToPostingMode 

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

EXPORT_C void CGlxHdmiController::ShiftToPostingMode()

    {

    TRACER("CGlxHdmiController::ShiftToPostingMode()");

    iIsPhotosInForeground = ETrue;

    if (iGlxTvOut->IsHDMIConnected())

        {

        if (!iSurfaceUpdater)

            {

            GLX_LOG_INFO("CGlxHdmiController::ShiftToPostingMode() - 1");

            // This case would come when HDMI connected, TvOut /headphones being connected

            // and then it shows a popup of "microphone connected" 

            // thus Background - Foreground when headphones connected during HDMI connected

            if (iFsBitmap == NULL || !iStoredImagePath->Length())

                {

                return;

                }

            }

        else

            {

            GLX_LOG_INFO("CGlxHdmiController::ShiftToPostingMode() - 2");

            iSurfaceUpdater->ShiftToPostingMode();

            }

        }

    }

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

// IsHDMIConnected 

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

EXPORT_C TBool CGlxHdmiController::IsHDMIConnected()

    {

    TRACER("CGlxHdmiController::IsHDMIConnected()");

    }

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

// Constructor

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

    {

    TRACER("CGlxHdmiController::CGlxHdmiController()");

    // Implement nothing here

    }

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

// ConstructL 

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

void CGlxHdmiController::ConstructL()

    {

    TRACER("CGlxHdmiController::ConstructL()");

    iGlxTvOut = CGlxTv::NewL(*this);

    }

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

// DestroyContainer 

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

void CGlxHdmiController::DestroyContainer()

    {

    TRACER("CGlxHdmiController::DestroyContainer()");

    if (iHdmiContainer)

        {

        delete iHdmiContainer;

        iHdmiContainer = NULL;

        }

    }

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

// DestroySurfaceUpdater 

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

void CGlxHdmiController::DestroySurfaceUpdater()

    {

    TRACER("CGlxHdmiController::DestroySurfaceUpdater()");

    if (iSurfaceUpdater)

        {

        delete iSurfaceUpdater;

        iSurfaceUpdater = NULL;

    }

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

// CreateHdmiContainerL 

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

void CGlxHdmiController::CreateHdmiContainerL()

    {

    TRACER("CGlxHdmiController::CreateHdmiContainer()");

    TRect rect = AlfUtil::ScreenSize();

    iHdmiContainer = CGlxHdmiContainer::NewL(rect);

    }

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

// CreateSurfaceUpdaterL 

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

    {

    TRACER("CGlxHdmiController::CreateSurfaceUpdater()");

    RWindow* window = iHdmiContainer->GetWindow();

    iHdmiContainer->DrawNow();

    }

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

// StoreImageInfoL 

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

    {

    TRACER("CGlxHdmiController::StoreImageInfoL()");

        {

        delete iStoredImagePath;

        iStoredImagePath = NULL;

        }

    if (iFsBitmap)

        {

        delete iFsBitmap;

        iFsBitmap = NULL;

        }

    iStoredImagePath = aImageFile.AllocL();

    iFsBitmap = new (ELeave) CFbsBitmap;

    iFsBitmap->Duplicate(aFsBitmap->Handle());

    }

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

// HandleTvStatusChangedL 

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

    {

    TRACER("CGlxHdmiController::HandleTvStatusChangedL()");

        {

            {

            // Do nothing , as this means HDMI is already connected and headset/tv cable connected

            // meaning we shouldnt destroy HDMI and neither have to create surface updater.

            return;

            }

            {

            // Calling SetImageL() with appropriate parameters

            }

        else

            {

            // if it gets disconnected, destroy the surface 

            DestroySurfaceUpdater();

            }

        }

    }