/*

* 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:  This class implements MMMADisplayWindow functionality

*                for Camera viewfinder usage.

*

*/

//  Include Files

#include <eikenv.h>

#include <gdi.h>

#include <jdebug.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <cameraapp.mbg>

// Used for iDisplay member

#include "cmmacamerawindow.h"

// Camera viewfinder start delay

const TInt KStarterTimeout = 100000; //100 msecs

// Margin of icon displayed instead of viewfinder in case of error

const TInt KErrorIconMargin = 5; //5 pixels

_LIT(KCameraAppBitmapFile, "z:\\resource\\apps\\cameraapp.mif");

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

// CMMACameraWindow::NewL

// Two-phased constructor.

// Use this method to create a CMMACameraWindow instance.

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

//

CMMACameraWindow* CMMACameraWindow::NewL(TInt aCameraHandle)

{

    CMMACameraWindow* self = new(ELeave)CMMACameraWindow(aCameraHandle);

    return self;

}

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

// CMMACameraWindow::~CMMACameraWindow

// Destructor.

// NOTE: iUICamera have to be deleted by ReleaseUiResources() called

//       from UI thread

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

//

CMMACameraWindow::~CMMACameraWindow()

{

    // It's not allowed to delete any nonsharable object here.

    // This must be done in Destroy().

    // If the iDisplay is set,

    // instance should be deleted by sending

    // event from UI to be received by MUiEventConsumer.

}

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

// CMMACameraWindow::ViewFinderActive

// Gets an information if the viewfinder is started.

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

//

TBool CMMACameraWindow::ViewFinderActive()

{

    return iUICamera && iViewFinderVisible;

}

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

// CMMACameraWindow::SetStarted

// Notifies window about Started state change.

// If started, tries to start viewfinder.

// If not started, stops viewfinder.

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

//

void CMMACameraWindow::SetStarted(TBool aStarted)

{

    iStarted = aStarted;

    if (iDisplay)

    {

        if (iStarted)

        {

            iDisplay->UIGetCallback(

                *this, CMMACameraWindow::EShowViewFinder);

        }

        else

        {

            iDisplay->UIGetCallback(

                *this, CMMACameraWindow::EHideViewFinder);

        }

    }

}

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

// CMMACameraWindow::SetDisplay

// Sets iDisplay used to invoke callbacks from UI thread.

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

//

void CMMACameraWindow::SetDisplay(MMMADisplay *aDisplay)

{

    if (iDisplay != aDisplay)

    {

        if (iDisplay)

        {

            // Clear the resources created within the old Display

            iDisplay->UIGetCallback(

                *this, CMMACameraWindow::EDeleteViewFinder);

        }

        // Set the new Display

        iDisplay = aDisplay;

        if (iDisplay)

        {

            // Get a DSA resources for the new Display

            iDisplay->UIGetDSAResources(*this, MMMADisplay::EMmaThread);

        }

    }

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::SetDestinationBitmapL

//

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

//

void CMMACameraWindow::SetDestinationBitmapL(CFbsBitmap* /*aBitmap*/)

{

    // Ignored, this window will not be used for actual drawing

    DEBUG("CMMACameraWindow::SetDestinationBitmapL");

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::DrawFrameL

//

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

//

void CMMACameraWindow::DrawFrameL(const CFbsBitmap* /*aBitmap*/)

{

    // Ignored, this window will not be used for actual drawing

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::SetDrawRect

//

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

//

void CMMACameraWindow::SetDrawRect(const TRect& aRect)

{

    // MMAPI thread

    DEBUG_INT2("MMA::CMMACameraWindow::SetDrawRect TL:%d,%d",

               aRect.iTl.iX, aRect.iTl.iY);

    DEBUG_INT2("MMA::CMMACameraWindow::SetDrawRect BR:%d,%d",

               aRect.iBr.iX, aRect.iBr.iY);

    iDrawRect = aRect;

    if (iDisplay)

    {

        iDisplay->UIGetCallback(*this, CMMACameraWindow::EResetViewFinder);

    }

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::SetDrawRectThread

//

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

//

void CMMACameraWindow::SetDrawRectThread(const TRect& aRect)

{

    DEBUG_INT2("MMA::CMMACameraWindow::SetDrawRectThread TL:%d,%d",

               aRect.iTl.iX, aRect.iTl.iY);

    DEBUG_INT2("MMA::CMMACameraWindow::SetDrawRectThread BR:%d,%d",

               aRect.iBr.iX, aRect.iBr.iY);

    // Note: Runs in UI thread only

    // Bitmap window's rect can be set in any thread.

    if (iDrawRect != aRect)

    {

        iDrawRect = aRect;

        // Stop and start ViewFinder to update position

        ResetViewFinder();

    }

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::DrawRect

//

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

//

const TRect& CMMACameraWindow::DrawRect()

{

    return iDrawRect;

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::WindowSize

//

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

//

TSize CMMACameraWindow::WindowSize()

{

    return iDrawRect.Size();

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::SetPosition

//

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

//

void CMMACameraWindow::SetPosition(const TPoint& aPosition)

{

    // Note: Runs in UI thread only

    SetDrawRectThread(TRect(aPosition, iDrawRect.Size()));

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::SetVisible

//

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

//

void CMMACameraWindow::SetVisible(TBool aVisible, TBool aUseEventServer)

{

    iVisible = aVisible;

    if (aUseEventServer)

    {

        // We are in UI thread now.

        SetViewFinderVisibility(aVisible);

    }

    else

    {

        // MMAPI thread

        if (iDisplay)

        {

            if (aVisible)

            {

                iDisplay->UIGetCallback(

                    *this, CMMACameraWindow::EShowViewFinder);

            }

            else

            {

                iDisplay->UIGetCallback(

                    *this, CMMACameraWindow::EHideViewFinder);

            }

        }

    }

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::SetWindowRect

//

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

//

void CMMACameraWindow::SetWindowRect(

    const TRect& aRect,

    MMMADisplay::TThreadType aThreadType)

{

    DEBUG_INT2("MMA::CMMACameraWindow::SetWindowRect TL:%d,%d",

               aRect.iTl.iX, aRect.iTl.iY);

    DEBUG_INT2("MMA::CMMACameraWindow::SetWindowRect BR:%d,%d",

               aRect.iBr.iX, aRect.iBr.iY);

    if (iClientRect != aRect)

    {

        iClientRect = aRect;

        if (aThreadType == MMMADisplay::EUiThread)

        {

            ResetViewFinder();

        }

        else

        {

            iDisplay->UIGetCallback(

                *this, CMMACameraWindow::EResetViewFinder);

        }

    }

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::WindowRect

//

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

//

const TRect& CMMACameraWindow::WindowRect()

{

    return iClientRect;

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::GetDisplayWindowType

//

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

//

MMMADisplayWindow::TDisplayWindowType

CMMACameraWindow::GetDisplayWindowType() const

{

    return EDisplayWindowTypeIsCamera;

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::IsVisible

//

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

//

TBool CMMACameraWindow::IsVisible() const

{

    return iVisible;

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::ContainerSet

//

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

//

void CMMACameraWindow::ContainerSet()

{

    // We are in UI thread now

    // Container was probably not set when

    // iDisplay was set,

    // we can now try get the DSA stuff again

    if (!iUICamera && iDisplay)

    {

        // Get a DSA stuff for the new Display

        iDisplay->UIGetDSAResources(*this, MMMADisplay::EUiThread);

    }

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::ContainerDestroyed

//

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

//

void CMMACameraWindow::ContainerDestroyed()

{

    // We are in UI thread now

    ReleaseUiResources();

}

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

// From class MCameraObserver

// CMMACameraWindow::ReserveComplete

//

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

//

void CMMACameraWindow::ReserveComplete(TInt aError)

{

    DEBUG_INT("MMA::CMMACameraWindow::ReserveComplete %d", aError);

    if (aError == KErrNone)

    {

        // camera will notify completion with PowerOnComplete method.

        iUICamera->PowerOn();

    }

}

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

// From class MCameraObserver

// CMMACameraWindow::PowerOnComplete

//

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

//

void CMMACameraWindow::PowerOnComplete(TInt aError)

{

    DEBUG_INT("MMA::CMMACameraWindow::PowerOnComplete %d", aError);

    if (aError == KErrNone)

    {

        iCameraPowerOn = ETrue;

        SetViewFinderVisibility(ETrue);

    }

}

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

// From class MCameraObserver

// CMMACameraWindow::ViewFinderFrameReady

//

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

//

void CMMACameraWindow::ViewFinderFrameReady(CFbsBitmap& /*aFrame*/)

{

    // Empty implementation of the interface method

    DEBUG("MMA::CMMACameraWindow::ViewFinderFrameReady");

}

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

// From class MCameraObserver

// CMMACameraWindow::ImageReady

//

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

//

void CMMACameraWindow::ImageReady(CFbsBitmap* /*aBitmap*/,

                                  HBufC8* /*aData*/,

                                  TInt /*aError*/)

{

    // Empty implementation of the interface method

    DEBUG("MMA::CMMACameraWindow::ImageReady");

}

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

// From class MCameraObserver

// CMMACameraWindow::FrameBufferReady

//

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

//

void CMMACameraWindow::FrameBufferReady(MFrameBuffer* /*aFrameBuffer*/,

                                        TInt /*aError*/)

{

    // Empty implementation of the interface method

    DEBUG("MMA::CMMACameraWindow::FrameBufferReady");

}

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

// From class MDirectScreenAccess.

// CMMACameraWindow::AbortNow

//

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

//

void CMMACameraWindow::AbortNow(

    RDirectScreenAccess::TTerminationReasons /*aReasons*/)

{

    SetViewFinderVisibility(EFalse);

}

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

// From class MDirectScreenAccess.

// CMMACameraWindow::Restart

//

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

//

void CMMACameraWindow::Restart(

    RDirectScreenAccess::TTerminationReasons /*aReasons*/)

{

    SetViewFinderVisibility(ETrue);

}

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

// CMMACameraWindow::CMMACameraWindow

// C++ constructor.

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

//

CMMACameraWindow::CMMACameraWindow(TInt aCameraHandle):

        iVisible(EFalse),

        iStarted(EFalse),

        iViewFinderVisible(EFalse),

        iCameraPowerOn(EFalse),

        iDrawRect(0, 0, 0, 0),

        iClientRect(0, 0, 0, 0),

        iCameraHandle(aCameraHandle),

        iUICamera(NULL),

        iDisplay(NULL),

        iStarterTimer(NULL),

        iDirectAccess(NULL),

        iErrorIconBitmap(NULL),

        iErrorIconMaskBitmap(NULL),

        iRWindowRect(0, 0, 0, 0)

{

}

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

// CMMACameraWindow::UIStartViewFinder

// Creates UI Camera.

// This CCamera instance is duplicated from handle given to the constructor.

// Have to be called from the thread which UI Camera will be controlled from.

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

//

void CMMACameraWindow::UIStartViewFinder(

    RWsSession &aWs,

    CWsScreenDevice &aScreenDevice,

    RWindowBase &aWindow)

{

    DEBUG("MMA::CMMACameraWindow::UIStartViewFinder");