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

#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
// -----------------------------------------------------------------------------
EXPORT_C CGlxHdmiController* CGlxHdmiController::NewL(
        MGlxHDMIDecoderObserver& aDecoderObserver)
    {
    TRACER("CGlxHdmiController* CGlxHdmiController::NewL()");
    CGlxHdmiController* self = new (ELeave) CGlxHdmiController(
            aDecoderObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// destructor 
// -----------------------------------------------------------------------------
EXPORT_C CGlxHdmiController::~CGlxHdmiController()
    {
    TRACER("CGlxHdmiController::~CGlxHdmiController()");
    DestroySurfaceUpdater();
    DestroyContainer();
    delete iStoredImagePath;
    delete iStoredNextImagePath;
    if (iFsBitmap)
        {
        delete iFsBitmap;
        }
    if (iGlxTvOut)
        {
        delete iGlxTvOut;
        }
    }

// -----------------------------------------------------------------------------
// Setting an Image Path 
// -----------------------------------------------------------------------------
EXPORT_C void CGlxHdmiController::SetImageL(const TDesC& aImageFile,
        const TDesC& aNextImageFile, CFbsBitmap* aFsBitmap, TBool aStore)
    {
    TRACER("CGlxHdmiController::SetImageL()");
    if (aFsBitmap == NULL || !aImageFile.Length())
        {
        GLX_LOG_INFO("CGlxHdmiController::SetImageL() - NULL Uri");
        return;
        }
    if (aStore)
        {
        iIsImageSupported = ETrue;
        StoreImageInfoL(aImageFile, aNextImageFile, aFsBitmap);
        }
    if (iGlxTvOut->IsHDMIConnected())
        {
        iIsPhotosInForeground = ETrue; // the image should be in posting mode
        GLX_LOG_INFO("CGlxHdmiController::SetImageL() - 2");
        // do not close the surface , use the same surface instead.
        // Call a function to pass imagefile
        if (!iHdmiContainer)
            {
            CreateHdmiContainerL();
            }
        if (!iSurfaceUpdater)
            {
            // This case would come when surface updater is not created at the first instance and also
            // it satisfies the 720p condition                
            CreateSurfaceUpdaterL(aImageFile, aNextImageFile);
            }
        else
            {
            GLX_LOG_INFO("CGlxHdmiController::SetImageL() - 3");
            iSurfaceUpdater->UpdateNewImageL(aImageFile, aNextImageFile,
                    aFsBitmap);
            }
        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() && iIsImageSupported)
        {
        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())
                {
                GLX_LOG_INFO(
                        "CGlxHdmiController::ShiftToPostingMode() - NULL Uri");
                return;
                }
            SetImageL(iStoredImagePath->Des(), KNullDesC, iFsBitmap, EFalse);
            }
        else
            {
            GLX_LOG_INFO("CGlxHdmiController::ShiftToPostingMode() - 2");
            iSurfaceUpdater->ShiftToPostingMode();
            }
        }
    }

// -----------------------------------------------------------------------------
// IsHDMIConnected 
// -----------------------------------------------------------------------------
EXPORT_C TBool CGlxHdmiController::IsHDMIConnected()
    {
    TRACER("CGlxHdmiController::IsHDMIConnected()");
    return iGlxTvOut->IsHDMIConnected();
    }

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
CGlxHdmiController::CGlxHdmiController(
        MGlxHDMIDecoderObserver& aDecoderObserver) :
    iFsBitmap(NULL), iStoredImagePath(NULL), iStoredNextImagePath(NULL),
            iIsPhotosInForeground(EFalse), iDecoderObserver(aDecoderObserver)
    {
    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)
        {
        GLX_LOG_INFO(
                "CGlxHdmiController::DestroyHdmi() - deleting iHdmiContainer 1");
        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 
// -----------------------------------------------------------------------------
void CGlxHdmiController::CreateSurfaceUpdaterL(const TDesC& aImageFile,
        const TDesC& aNextImageFile)
    {
    TRACER("CGlxHdmiController::CreateSurfaceUpdater()");
    RWindow* window = iHdmiContainer->GetWindow();
    iSurfaceUpdater = CGlxHdmiSurfaceUpdater::NewL(window, aImageFile,
            aNextImageFile, iFsBitmap, iHdmiContainer, iDecoderObserver);
    iHdmiContainer->DrawNow();
    }

// -----------------------------------------------------------------------------
// StoreImageInfoL 
// -----------------------------------------------------------------------------
void CGlxHdmiController::StoreImageInfoL(const TDesC& aImageFile,
        const TDesC& aNextImageFile, CFbsBitmap* aFsBitmap)
    {
    TRACER("CGlxHdmiController::StoreImageInfoL()");
    if (iStoredImagePath)
        {
        delete iStoredImagePath;
        iStoredImagePath = NULL;
        }
    if (iStoredNextImagePath)
        {
        delete iStoredNextImagePath;
        iStoredNextImagePath = NULL;
        }
    if (iFsBitmap)
        {
        delete iFsBitmap;
        iFsBitmap = NULL;
        }
    iStoredImagePath = aImageFile.AllocL();
    iStoredNextImagePath = aNextImageFile.AllocL();
    iFsBitmap = new (ELeave) CFbsBitmap;
    iFsBitmap->Duplicate(aFsBitmap->Handle());
    }

// -----------------------------------------------------------------------------
// HandleTvStatusChangedL 
// -----------------------------------------------------------------------------
void CGlxHdmiController::HandleTvStatusChangedL(TTvChangeType aChangeType)
    {
    TRACER("CGlxHdmiController::HandleTvStatusChangedL()");
    if (aChangeType == ETvConnectionChanged)
        {
        if (iGlxTvOut->IsHDMIConnected() && iGlxTvOut->IsConnected()
                && iSurfaceUpdater)
            {
            GLX_LOG_INFO(
                    "CGlxHdmiController::HandleTvStatusChangedL() - HDMI and TV Connected");
            // 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;
            }
        else if (iGlxTvOut->IsHDMIConnected() && iIsImageSupported
                && iIsPhotosInForeground)
            {
            GLX_LOG_INFO(
                    "CGlxHdmiController::HandleTvStatusChangedL() - HDMI Connected");
            // Calling SetImageL() with appropriate parameters
            if (iStoredNextImagePath)
                {
                SetImageL(iStoredImagePath->Des(),
                        iStoredNextImagePath->Des(), iFsBitmap, EFalse);
                }
            else
                {
                SetImageL(iStoredImagePath->Des(), KNullDesC, iFsBitmap,
                        EFalse);
                }
            }
        else
            {
            GLX_LOG_INFO3(
                    "CGlxHdmiController::HandleTvStatusChangedL() iIsImageSupported=%d, iGlxTvOut->IsHDMIConnected()=%d, iIsPostingMode=%d",
                    iIsImageSupported, iGlxTvOut->IsHDMIConnected(),
                    iIsPhotosInForeground);
            // if it gets disconnected, destroy the surface 
            GLX_LOG_INFO(
                    "CGlxHdmiController::HandleTvStatusChangedL() - HDMI Not Connected");
            DestroySurfaceUpdater();
            }
        }
    }