/*

* 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 <logger.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include "cmmacanvasdisplay.h"

#include "logger.h"

class CMMACanvasDisplay;

//#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);

            LOG(EJavaMMAPI,EInfo,"CMMACameraWindow::SetStarted : before GetCallbackInUiThread + EShowViewFinder");

            iDisplay->GetCallbackInUiThread((TInt)CMMACameraWindow::EShowViewFinder);

        }

        else

        {

            //   iDisplay->UIGetCallback(

            //       *this, CMMACameraWindow::EHideViewFinder);

            LOG(EJavaMMAPI,EInfo,"CMMACameraWindow::SetStarted : before GetCallbackInUiThread + EHideViewFinder");

            iDisplay->GetCallbackInUiThread((TInt)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);

            // instead make a call to java, shift to ui thread and call ReleaseUiResources() method in UI thread

            // here jobject and jclass is valid since the flow is first creat CMMACanvasDisplay and then

            // call setdeisplay of cameraplayer

            /*iJavaDisplayObject = iDisplay->GetJavaDisplayObject();

            iJavaDisplayClass = iDisplay->GetJavaDisplayClass();

            iJni = iDisplay->GetJNIEnv();

             jmethodID releaseUiResourceID = iJni->GetMethodID(

                                         iJavaDisplayClass,

                                         "releaseUiResource",

                                         "()I");

             iJni->CallIntMethod(iJavaDisplayObject,releaseUiResourceID);*/

            //MMAPI UI 3.x req.

            LOG(EJavaMMAPI,EInfo,"CMMACameraWindow::SetDisplay : before GetCallbackInUiThread +");

            iDisplay->GetCallbackInUiThread((TInt)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

    LOG(EJavaMMAPI,EInfo,"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

    LOG2(EJavaMMAPI,EInfo,"MMA::CMMACameraWindow::SetDrawRect TL:%d,%d",

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

    LOG2(EJavaMMAPI,EInfo,"MMA::CMMACameraWindow::SetDrawRect BR:%d,%d",

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

    iDrawRect = aRect;

    if (iDisplay)

    {

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

        LOG(EJavaMMAPI,EInfo,"CMMACameraWindow::SetDisplay : before GetCallbackInUiThread + EResetViewFinder");

        iDisplay->GetCallbackInUiThread((TInt)CMMACameraWindow::EResetViewFinder);

    }

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::SetDrawRectThread

//

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

//

void CMMACameraWindow::SetDrawRectThread(const TRect& aRect)

{

    LOG2(EJavaMMAPI, EInfo, "MMA::CMMACameraWindow::SetDrawRectThread TL:%d,%d",

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

    LOG2(EJavaMMAPI, EInfo, "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);

                LOG(EJavaMMAPI,EInfo,"CMMACameraWindow::SetVisible : before GetCallbackInUiThread - EShowViewFinder");

                iDisplay->GetCallbackInUiThread((TInt)CMMACameraWindow::EShowViewFinder);

            }

            else

            {

                // iDisplay->UIGetCallback(

                //     *this, CMMACameraWindow::EHideViewFinder);

                LOG(EJavaMMAPI,EInfo,"CMMACameraWindow::SetVisible : before GetCallbackInUiThread - EHideViewFinder");

                iDisplay->GetCallbackInUiThread((TInt)CMMACameraWindow::EHideViewFinder);

            }

        }

    }

}

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

// From class MMMADisplayWindow

// CMMACameraWindow::SetWindowRect

//

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

//

void CMMACameraWindow::SetWindowRect(

    const TRect& aRect,

    MMMADisplay::TThreadType aThreadType)

{

    LOG2(EJavaMMAPI, EInfo, "MMA::CMMACameraWindow::SetWindowRect TL:%d,%d",

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

    LOG2(EJavaMMAPI, EInfo, "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);

            LOG(EJavaMMAPI,EInfo,"CMMACameraWindow::SetWindowRect : before GetCallbackInUiThread + EResetViewFinder");

            iDisplay->GetCallbackInUiThread((TInt)CMMACameraWindow::EHideViewFinder);

        }

    }

}

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

// 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)

{

    LOG1(EJavaMMAPI,EInfo,"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)

{

    ELOG1(EJavaMMAPI, "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

    LOG(EJavaMMAPI,EInfo,"MMA::CMMACameraWindow::ViewFinderFrameReady");

}

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

// From class MCameraObserver

// CMMACameraWindow::ImageReady

//

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

//

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

                                  HBufC8* /*aData*/,

                                  TInt /*aError*/)

{

    // Empty implementation of the interface method

    LOG(EJavaMMAPI,EInfo,"MMA::CMMACameraWindow::ImageReady");

}

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

// From class MCameraObserver

// CMMACameraWindow::FrameBufferReady

//

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

//

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

                                        TInt /*aError*/)

{

    // Empty implementation of the interface method

    LOG(EJavaMMAPI,EInfo,"MMA::CMMACameraWindow::FrameBufferReady");

}

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

// From class MDirectScreenAccess.

// CMMACameraWindow::AbortNow

//

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

//

void CMMACameraWindow::AbortNow(

    RDirectScreenAccess::TTerminationReasons /*aReasons*/)

{

    SetViewFinderVisibility(EFalse);

}