/*

 * Name        : ARContainer.cpp

 * Description : 

 * Project     : This file is part of OpenMAR, an Open Mobile Augmented Reality browser

 * Website     : http://OpenMAR.org

 *

 * Copyright (c) 2010 David Caabeiro

 *

 * All rights reserved. This program and the accompanying materials are made available 

 * under the terms of the Eclipse Public License v1.0 which accompanies this 

 * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html

 *

 */

#include "ARContainer.h"

#include <coemain.h>

#include <eikenv.h>

#include <AknButton.h>

#include <AknNoteWrappers.h>

#include <AknView.h>

#include "Application.hrh"

#include <OpenMAR_0x2002E1AB.rsg>

#include <Button_0x2002E1AB.mbg>

#include "IconLoader.h"

#include "ResetAndDestroy.h"

#include "Logger.h"

// Constant definitions

_LIT(KButtonFile, "\\resource\\apps\\Button_0x2002E1AB.mif");

const TSize KButtonSize(36, 36);

CARContainer* CARContainer::NewL(CAknView& aView, const TRect& aRect)

{

    CARContainer* self = new(ELeave) CARContainer(aView);

    CleanupStack::PushL(self);

    self->ConstructL(aRect);

    CleanupStack::Pop(self);

    return self;

}

CARContainer::CARContainer(CAknView& aView)

    : iView(aView)

{}

void CARContainer::ConstructL(const TRect& aRect)

{

    CreateWindowL();

    CreateButtonGroupL();

    // This bitmap will contain the camera frame and overlays

    iBitmap = new(ELeave) CFbsBitmap;

    iBitmap->Create(aRect.Size(), Window().DisplayMode());

    iBitmapDevice = CFbsBitmapDevice::NewL(iBitmap);

    User::LeaveIfError(iBitmapDevice->CreateContext(iBitmapContext));

    // Make black background to be shown immediately to the user 

    iBitmapContext->SetBrushColor(KRgbBlack);

    iBitmapContext->SetBrushStyle(CFbsBitGc::ESolidBrush);

    iBitmapContext->Clear();

    SetRect(aRect);

    LOGARG("Control rect size is %d x %d", aRect.Width(), aRect.Height());

    iCoeEnv->AddForegroundObserverL(*this);

#if defined(__MARM__)

    iCamera = CDigitalCamera::NewL(*this);

    // The rect will be the intersection between the camera frame

    // and the window rect

    TRect cameraRect(TPoint(0, 0), iCamera->ViewportSize());

    cameraRect.Intersection(aRect);

#else

    TRect cameraRect(aRect);

#endif

    LOGARG("Viewport rect is (%d, %d, %d, %d)", 

            cameraRect.iTl.iX, cameraRect.iTl.iY, cameraRect.iBr.iX, cameraRect.iBr.iY);

    iScreenshot = CScreenshot::NewL(*this, cameraRect.Size(), Window().DisplayMode());

    // Instantiate overlay implementations

    RImplInfoPtrArray implementations;

    REComSession::ListImplementationsL(TUid::Uid(KOverlayInterfaceUidValue), implementations);

    CleanupResetAndDestroyPushL(implementations);

    // Pass container window and rect size to each overlay

    OpenMAR::CPOIOverlay::SParameter param = { Window(), cameraRect };

    for (TInt i = 0; i < implementations.Count(); ++i)

    {

        const CImplementationInformation* info = implementations[i];

        OpenMAR::CPOIOverlay* plugin = OpenMAR::CPOIOverlay::NewL(info->ImplementationUid(), param);

        iOverlayList.AppendL(plugin);

    }

    CleanupStack::PopAndDestroy(&implementations);

    // Start camera in low priority task

    iSensorTask = CIdle::NewL(CActive::EPriorityIdle);

    TCallBack sensorStart(SensorStart, this);

    iSensorTask->Start(sensorStart);

    ActivateL();

}

CARContainer::~CARContainer()

{

    DoSensorStop();

    iOverlayList.ResetAndDestroy();

    iOverlayList.Close();

    delete iCamera;

    delete iScreenshot;

    iCoeEnv->RemoveForegroundObserver(*this);

    delete iBitmapContext;

    delete iBitmapDevice;

    delete iBitmap;

    DeleteButtonGroup();

}

void CARContainer::CreateButtonGroupL()

{

    // Screenshot button

    CGulIcon* screenshotNormal = CreateIconL(KButtonFile, EMbmButton_0x2002e1abScreenshotbuttonnormal, EMbmButton_0x2002e1abScreenshotbuttonnormal_mask, KButtonSize);

    iScreenshotButton = CAknButton::NewL(screenshotNormal, 0, 0, 0, KNullDesC, KNullDesC, KAknButtonNoFrame, 0);

    iScreenshotButton->SetContainerWindowL(*this);

    iScreenshotButton->SetObserver(this);

}

void CARContainer::DeleteButtonGroup()

{

    delete iScreenshotButton;

}

TInt CARContainer::SensorStart(TAny* aPtr)

{

    CARContainer* self = static_cast<CARContainer*>(aPtr);

    self->DoSensorStart();

    return KErrNone;

}

void CARContainer::DoSensorStart()

{

    LOGTXT("Starting sensors..");

#if defined(__MARM__)

    iCamera->Start();

#endif

    for (TInt i = 0; i < iOverlayList.Count(); ++i)

        iOverlayList[i]->StartL();

}

TInt CARContainer::SensorStop(TAny* aPtr)

{

    CARContainer* self = static_cast<CARContainer*>(aPtr);

    self->DoSensorStop();

    return KErrNone;

}

void CARContainer::DoSensorStop()

{

    LOGTXT("Stopping sensors..");

    for (TInt i = 0; i < iOverlayList.Count(); ++i)

        iOverlayList[i]->Stop();

#if defined(__MARM__)

    iCamera->Stop();

#endif

}

/*

 * Before performing the screenshot, disable overlay and sensor activity.

 * This way the screenshot image is generated fast.

 */  

void CARContainer::ScreenshotStartL()

{

    iScreenshotButton->SetDimmed(ETrue);

    HandleLosingForeground();

    iScreenshot->RequestL(*iBitmap, iBitmap->SizeInPixels());

}

/*

 * Resume overlay and sensor activity.

 */

void CARContainer::ScreenshotStop()

{

    HandleGainingForeground();

    iScreenshotButton->SetDimmed(EFalse);

}

void CARContainer::SizeChanged()

{

    TRect screenshotButtonRect(TPoint(0, 0), KButtonSize);

    screenshotButtonRect.Move(TPoint(Rect().Width() - KButtonSize.iWidth, Rect().Height() - KButtonSize.iHeight));

    iScreenshotButton->SetRect(screenshotButtonRect);

}

void CARContainer::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

//    if (aPointerEvent.iType == TPointerEvent::EButton1Down && iCamera)

//        iCamera->StartFocus();

    CCoeControl::HandlePointerEventL(aPointerEvent);

}

void CARContainer::HandleResourceChange(TInt aType)

{

    LOGARG("CARContainer::HandleResourceChange(%d)", aType);

    CCoeControl::HandleResourceChange(aType);

/*

    if (aType == KEikDynamicLayoutVariantSwitch)

    {

        TRect rect;

        AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EApplicationWindow, rect);

        SetRect(rect);

    }

*/

}

void CARContainer::Draw(const TRect& /*aRect*/) const

{

    CWindowGc& gc = SystemGc();

    gc.BitBlt(TPoint(0, 0), iBitmap);

}

TInt CARContainer::CountComponentControls() const

{

    return ETotal;

}

CCoeControl* CARContainer::ComponentControl(TInt aIndex) const

{

    switch (aIndex)

    {

        case EScreenshot:

            return iScreenshotButton;

        default:

            return 0;

    }

}

void CARContainer::HandleControlEventL(CCoeControl* aControl, TCoeEvent aEventType)

{

    if (aEventType == EEventStateChanged)

    {

        if (aControl == iScreenshotButton)

        {

            LOGTXT("Screenshot requested");

            ScreenshotStartL();

        }

    }

}

void CARContainer::HandleGainingForeground()

{

    LOGTXT("Gaining ForegroundL");

    // Clear bitmap to avoid showing screen capture when back

    iBitmapContext->SetBrushColor(KRgbBlack);

    iBitmapContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

    iBitmapContext->Clear();

    iSensorTask->Cancel();

    TCallBack sensor(SensorStart, this);

    iSensorTask->Start(sensor);

}

void CARContainer::HandleLosingForeground()

{

    LOGTXT("Losing foreground");

/*

    iSensorTask->Cancel();

    TCallBack sensor(SensorStop, this);

    iSensorTask->Start(sensor);

*/

    DoSensorStop();

}

void CARContainer::CameraReady(TInt aError)

{

    LOGARG("Camera ready (error %d)", aError);

    // Perform some error handling

}

void CARContainer::CameraFrame(CFbsBitmap& aFrame)

{

    // Use camera frame as background

    iBitmapContext->BitBlt(TPoint(0, 0), &aFrame);

    for (TInt i = 0; i < iOverlayList.Count(); ++i)

    {

        // Perform overlay rendering

        const CFbsBitmap& overlay = iOverlayList[i]->RenderScene();

        // Blend it with the background image

        iBitmapContext->BitBlt(TPoint(0, 0), &overlay);

    }

    const CFont* font = iEikonEnv->LegendFont();

    iBitmapContext->UseFont(font);

    _LIT(KText, "Focus: %d");

    TBuf<32> text;

    text.Format(KText, iOverlayList[0]->GetFocusedPOI());

    const TPoint pos(10, 20);

    iBitmapContext->DrawText(text, pos);

    // TODO: should call this every Nth frame

    User::ResetInactivityTime();

    DrawNow();

}

void CARContainer::FocusReady(TInt aError)

{

    if (aError == KErrNone)

        LOGTXT("Focused correctly");

//    else if (aError == KErrECamNotOptimalFocus)

//        LOGTXT("Focus not optimal");

}

void CARContainer::ScreenshotReadyL(TInt aError, const TDesC& aFilename)

{

    ScreenshotStop();

    TBuf<128> text;

    if (aError)

    {

        CAknErrorNote* note = new(ELeave) CAknErrorNote;

        HBufC* format = iEikonEnv->AllocReadResourceLC(R_SCREENSHOT_TEXT_ERROR);

        text.Format(*format, aError);

        CleanupStack::PopAndDestroy(format);

        note->ExecuteLD(text);

    }

    else

    {

        CAknInformationNote* note = new(ELeave) CAknInformationNote;

        HBufC* format = iEikonEnv->AllocReadResourceLC(R_SCREENSHOT_TEXT_OK);

        text.Format(*format, &aFilename);

        CleanupStack::PopAndDestroy(format);

        note->ExecuteLD(text);

    }

}