/*

* Copyright (c) 2007-2010 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:  Container base class for pre-capture views*

*/

// INCLUDE FILES

#include <eikmenub.h>

#include <aknview.h>

#include <w32std.h>

#include <gulutil.h>

#include <AknIconUtils.h>

#include <barsread.h>    // resource reader

#include <AknsFrameBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <eikenv.h>

#include <eikappui.h> // For CCoeAppUiBase

#include <eikapp.h>   // For CEikApplication

#include <layoutmetadata.cdl.h>            

#include <aknlayoutscalable_apps.cdl.h>    

#include <cameraapp.mbg>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include "CamAppUiBase.h"

#include "CamPreCaptureContainerBase.h"

#include "CamLogger.h"

#include "CamSidePane.h"

#include "CamUtility.h"

#include "CamPanic.h"

#include "Cam.hrh"

#include "CamAppUi.h"   

#include "CamIndicator.h"

#include "CamIndicatorResourceReader.h"

#include "CamIndicatorData.h"

#include "CamSelfTimer.h"

#include "CamPreCaptureViewBase.h"

#include "CamStillPreCaptureView.h"

#include "CamSettings.hrh"

#include "CamNaviCounterControl.h"

#include "CamNaviProgressBarControl.h"

#include "camuiconstants.h" // KCamDirectColorVal

#include "camactivepalettehandler.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamPreCaptureContainerBaseTraces.h"

#endif

#include "camconfiguration.h"

#include "CameraUiConfigManager.h"

// CONSTANTS

const TInt KZoomPanelTimeout = 4000000;     // 4s 

const TInt KReticuleFlashTimeout = 250000;  // Quarter of a second (in microseconds).

const TInt KAFIconCorners = 4; // Hip to be square 

#include "camvfgridinterface.h"

#include "camlinevfgriddrawer.h"

// Snapshot data is needed in timelapse mode

const TUint KCameraEventInterest = ( ECamCameraEventClassVfControl      

                                   | ECamCameraEventClassVfData 

                                   | ECamCameraEventClassSsData 

                                   );

// ================= MEMBER FUNCTIONS =======================

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

// CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase

// Destructor

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

//

CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase()

  {

  PRINT( _L("Camera => ~CCamPreCaptureContainerBase" ))

  iController.ViewfinderWindowDeleted( &Window() );

  iController.RemoveSettingsObserver  ( this );

  iController.RemoveCameraObserver    ( this );

  iController.RemoveControllerObserver( this );    

    if ( iZoomTimer && iZoomTimer->IsActive() )

    {    

    iZoomTimer->Cancel();

    }

  delete iZoomTimer;

  delete iVfGridDrawer;

  if ( iController.UiConfigManagerPtr() && 

       iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

      {

      iAfIcons.ResetAndDestroy();

      iLayouts.Close(); 

      if ( iReticuleTimer && iReticuleTimer->IsActive() )

        {    

        iReticuleTimer->Cancel();

        }

      delete iReticuleTimer;    

      }

  CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

  iResolutionIndicators.ResetAndDestroy();

  iResolutionIndicators.Close();

  if ( iController.UiConfigManagerPtr() && 

       iController.UiConfigManagerPtr()->IsLocationSupported() )

      {

      PRINT( _L("Camera => ~CCamPreCaptureContainerBase - delete iLocationIconController" ))

      delete iLocationIconController;

      }

  delete iOffScreenBitmap;

  delete iBitmapDevice;

  delete iBitmapGc;

  // if shutting down, observers are removed automatically  

  if ( 

      iController.IsAppUiAvailable() &&

      appUi && !iController.IsInShutdownMode() )

    {

    // Deregister as burst mode observer

    appUi->RemoveBurstModeObserver( this );

    }

  delete iBatteryPaneController;

  delete iViewFinderBackup;

  iViewFinderBackup = NULL;

  iReceivedVfFrame = EFalse;

  PRINT( _L("Camera <= ~CCamPreCaptureContainerBase" ))

  }

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

// CCamPreCaptureContainerBase::BaseConstructL

// Symbian OS 2nd phase constructor

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

//

void CCamPreCaptureContainerBase::BaseConstructL( const TRect& aRect )

  {

  PRINT( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL ") );

  CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

  iZoomPane = appUi->ZoomPane();

  CCamContainerBase::BaseConstructL( aRect );

  iViewFinderBackup = NULL;

  iReceivedVfFrame = EFalse;

  // Check whether zoom & side pane will be on the left or the right of the screen

  TInt handedInt;

  User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiSidePanePosition, handedInt ) );

  iHandedness = static_cast< TCamHandedness >( handedInt );

  TResourceReader reader;                                                                                     

  iEikonEnv->CreateResourceReaderLC( reader, ROID(R_CAM_ZOOM_PANE_WIDTH_ID));    

  iZoomPaneWidth = reader.ReadInt16();

  CleanupStack::PopAndDestroy(); // reader

  // Create Zoom Pane based on Rect passed in on creation

  TRect paneRect( Rect() );

  // if the side pane is on the left

  if ( iHandedness == ECamHandLeft ) 

    { 

    paneRect.iBr.iX = iZoomPaneWidth;

    }

  else // the side pane is on the right

    {

    paneRect.iTl.iX = paneRect.iBr.iX - iZoomPaneWidth;    

    }

  User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiOverLaySidePane, iOverlayViewFinder ) );

  iController.AddControllerObserverL( this ); // For zoom state changes

  iController.AddCameraObserverL( this, KCameraEventInterest );

  iController.AddSettingsObserverL( this );

  iZoomPane->MakeVisible( EFalse, EFalse ); // On app startup, it's invisible

  if ( !appUi->IsSecondCameraEnabled() )

    {

    iZoomPane->SetZoomKeys( iPrimaryZoomInKeys, iPrimaryZoomOutKeys );

    }

  else

    {     

    iZoomPane->SetZoomKeys( iSecondaryZoomInKeys, iSecondaryZoomOutKeys );

    }

  iZoomTimer = CPeriodic::NewL( CActive::EPriorityUserInput );

  if ( iController.UiConfigManagerPtr() && 

       iController.UiConfigManagerPtr()->IsAutoFocusSupported() &&

       !iController.UiConfigManagerPtr()->IsFaceTrackingSupported() )

      {

      iReticuleTimer = CPeriodic::NewL( CActive::EPriorityUserInput );

      // Layout the reticule.                                                                                           

      iAfReadyIcon = CreateAfIconL( KRgbWhite );

      iAfFocusIcon = CreateAfIconL( KRgbGreen );

      iAfErrIcon   = CreateAfIconL( KRgbRed );

      }

  iSidePane = appUi->SidePane();

  iSidePane->SetRect( paneRect );

  // Register as burst mode observer

  appUi->AddBurstModeObserverL( this );

  CreateResolutionIndicatorL();

  if ( iController.UiConfigManagerPtr() && 

       iController.UiConfigManagerPtr()->IsLocationSupported() )

      {

      TRect Locrect = Rect();

      PRINT( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL - create iLocationIconController") )

      iLocationIconController = CCamLocationIconController::NewL( iController, *this, ETrue, Locrect );

      SetLocationIndicatorVisibility();

      }

  TBool dsaAlways( EFalse ); // Offscreen bitmap is needed with the emulator

  #ifndef __WINS__

  dsaAlways = iController.IsDirectScreenVFSupported( ETrue ) && 

              iController.IsDirectScreenVFSupported( EFalse );

  #endif

  if ( !dsaAlways )

      {

      // If bitmap VF is not possible in this configuration, 

      // offscreen bitmap is not needed

      TInt color;

      TInt gray;

      TDisplayMode displaymode =

          CEikonEnv::Static()->WsSession().GetDefModeMaxNumColors( color, gray );

      // set up the offscreen bitmap

      iOffScreenBitmap = new ( ELeave ) CFbsBitmap();  

      User::LeaveIfError( iOffScreenBitmap->Create( Rect().Size(), EColor16MU/*displaymode*/ ) );

      PRINT1( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL disp mode (%d)"), displaymode )

      iBitmapDevice = CFbsBitmapDevice::NewL( iOffScreenBitmap );

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

      }

  iRect = ViewFinderFrameRect();

  // if using direct viewfinding pass Rect to control

  if ( iController.UiConfigManagerPtr() && 

       iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

      {

      // Check whether we should be showing the reticule.

      // NOTE: This will only be showed in still, not video views

      iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();

      }

  // Setup viewfinder grid

  InitVfGridL( iRect );

  // Do not construct battery pane controller, if secondary camera is in use

  if ( iController.ActiveCamera() != ECamActiveCameraSecondary || 

       appUi->IsQwerty2ndCamera() ) 

    {

    iBatteryPaneController = CCamBatteryPaneController::NewL( 

                             *this, ETrue);  

    }

    // Make sure fixed toolbar is on top of this window

    DrawableWindow()->SetOrdinalPosition( KCamPreCaptureWindowOrdinalPos );

  iController.SetViewfinderWindowHandle( &Window() );

  appUi->SetViewFinderInTransit(EFalse);

  iController.StartIdleTimer();

  PRINT( _L("Camera <= CCamPreCaptureContainerBase::BaseConstructL ") );

  }

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

// CCamPreCaptureContainerBase::CCamPreCaptureContainerBase

// C++ constructor

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

//

CCamPreCaptureContainerBase::CCamPreCaptureContainerBase(

        CCamAppController& aController,

        CAknView& aView )

  : CCamContainerBase( aController, aView ),   

    iDisableRedraws( EFalse )

  {

  }

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

// CCamPreCaptureContainerBase::ZoomTimerCallback

// Callback for Zoom Pane timer

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

//

TInt CCamPreCaptureContainerBase::ZoomTimerCallback( TAny* aObject )

    {

    CCamPreCaptureContainerBase* cont = static_cast< CCamPreCaptureContainerBase* >( aObject );

    cont->ZoomTimerTick();

    return KErrNone;

    }

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

// CCamPreCaptureContainerBase::ReticuleTimerCallback

// Callback for flashing of the focus reticule

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

//

TInt CCamPreCaptureContainerBase::ReticuleTimerCallback( TAny* aObject )

    {

    CCamPreCaptureContainerBase* cont = static_cast< CCamPreCaptureContainerBase* >( aObject );

    cont->iReticuleFlashOn = !cont->iReticuleFlashOn;

    // This is where we force a redraw of the reticule, if we are using

    // Direct Viewfinding.  However, if we are in burst mode, we must

    // use Bitmap Viewfinding, so only draw reticule if NOT in burst mode

    CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

    if ( appUi && appUi-> IsDirectViewfinderActive() )

        {

        cont->DrawDeferred();

        }

    return KErrNone;

    }

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

// CCamPreCaptureContainerBase::ShowZoomPaneWithTimer

// Makes Zoom Pane visible for the period of the pane timer.

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

//

void CCamPreCaptureContainerBase::ShowZoomPaneWithTimer()

    {

    __ASSERT_DEBUG( iZoomTimer, CamPanic( ECamPanicNullPointer ) );

    __ASSERT_DEBUG( iZoomPane, CamPanic( ECamPanicNullPointer ) );  

    __ASSERT_DEBUG( iSidePane, CamPanic( ECamPanicNullPointer ) ); 

    PRINT(_L("Camera => CCamPreCaptureContainerBase::ShowZoomPaneWithTimer"));    

    // If already active, cancel the timer

    if ( iZoomTimer->IsActive() )

        {    

        iZoomTimer->Cancel();

        }

    iZoomTimer->Start( KZoomPanelTimeout, KZoomPanelTimeout, TCallBack( ZoomTimerCallback , this) );

    iZoomPane->MakeVisible( ETrue, ETrue );

    PRINT(_L("Camera <= CCamPreCaptureContainerBase::ShowZoomPaneWithTimer"));    

    }

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

// CCamPreCaptureContainerBase::ZoomTimerTick

// Called as a result of the Zoom Pane timer expiring, switches side panes

// to hide the Zoom pane.

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

//

void CCamPreCaptureContainerBase::ZoomTimerTick()

    {

    PRINT(_L("Camera => CCamPreCaptureContainerBase::ZoomTimerTick")); 

    // Cancel the (potentially) recurring timer

    iZoomTimer->Cancel();

    // If zooming is still in progress (this happens if the zoom key has

    // been held down longer than the zoom pane timer), keep the pane

    // visible

    if ( iZoomPane->IsCurrentlyZooming() )

        {

        iZoomTimer->Start( KZoomPanelTimeout,

                           KZoomPanelTimeout, 

                           TCallBack( ZoomTimerCallback , this) );

        }

    else

        {

        // Make Indicator Pane visible again and hide the ZoomPane

        iZoomPane->MakeVisible( EFalse, ETrue );

        // background needs redrawing behind zoom pane

        iRedrawPaneBackground = ETrue;

        }

    PRINT(_L("Camera <= CCamPreCaptureContainerBase::ZoomTimerTick")); 

    }

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

// CCamPreCaptureContainerBase::OfferKeyEventL

// Handles this application view's command keys. Forwards other

// keys to child control(s).

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

//

TKeyResponse 

CCamPreCaptureContainerBase::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                   TEventCode aType )

    {         

    PRINT2( _L("Camera => CCamPreCaptureContainerBase::OfferKeyEventL type %d) scan code (%d)"), aType, aKeyEvent.iScanCode )

#ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT

    // Log event only if this is the first capture key press and we are in correct state

    TCamCaptureOperation operation = iController.CurrentOperation();

    TBool isCaptureKeyForUs  = (IsCaptureKeyL( aKeyEvent, aType )

            && ( EEventKeyDown == aType && 0 == aKeyEvent.iRepeats ) );

    TBool isOperationStateOk = (ECamNoOperation == operation);

    if( isCaptureKeyForUs && isOperationStateOk )

        { 

        PERF_EVENT_START_L1( EPerfEventKeyToCapture );  

        }

#endif      

    TBool isCaptureKeyForSymbTrace  = (IsCaptureKeyL( aKeyEvent, aType )

            && ( EEventKeyDown == aType && 0 == aKeyEvent.iRepeats ) );

    if( isCaptureKeyForSymbTrace )

        {

        PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL Symbian Traces Active") );

        OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_CAPTURE_START 1" ); //CCORAPP_CAPTURE_START_START

        }

    iController.StartIdleTimer();

    if( aType == EEventKeyUp )

        {

        iController.SetDemandKeyRelease( EFalse ); 

        }

    CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

	__ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer) );

    if ( appUi->CheckCourtesyKeyEventL( aKeyEvent, aType, ETrue ) == EKeyWasConsumed )

        {

        PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL courtesy key") );

        return EKeyWasConsumed;

        }

    // If a control has the focus, give it the first opportunity to

    // process the key event

    if( iActivePalette 

            && iActivePalette->CoeControl()

            && iActivePalette->CoeControl()->OfferKeyEventL(aKeyEvent,aType) == EKeyWasConsumed )

        {

        PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL AP consumed") );

        return EKeyWasConsumed;

        }

    // The key press has not been handled by a visible control

    // so will be processed by the container.

    // Handle Zoom in key if we are not saving video

    PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL B") )

    if ( IsZoomKeyL( aKeyEvent, aType ) 

            && ECamCompleting != iController.CurrentOperation() 

            && !iController.CurrentlySavingVideo()

            && !appUi->IsSecondCameraEnabled() )

        {       

        // Offer the key event to the zoom pane/model

        TKeyResponse resp = iZoomPane->OfferKeyEventL( aKeyEvent, aType );

        // If it was consumed, we need to keep the zoom pane visible

        if ( resp == EKeyWasConsumed )

            {

            ShowZoomPaneWithTimer();

            }

        PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL Zoom key") );    

        return resp;

        }

    else if ( EEventKey == aType

            && EKeyOK    == aKeyEvent.iCode

            && 0         == aKeyEvent.iRepeats )

        {

        TBool MSKCapture(EFalse);

        if ( !appUi->IsToolBarVisible() && aKeyEvent.iScanCode == EStdKeyDevice3 )

            {

            MSKCapture = ETrue;

            }

        if( appUi->ActiveCamera() == ECamActiveCameraPrimary

                && !MSKCapture )

            {

            // AP needs to handle this

            PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL Ok key") );    

            return EKeyWasNotConsumed;

            }

        }

    // Handle right and left navi keys. 

    // Each product defines the behaviour that is mapped to these keys.        

    else if ( EEventKey == aType

            && ( EStdKeyRightArrow == aKeyEvent.iScanCode

                    || EStdKeyLeftArrow  == aKeyEvent.iScanCode ) )

        {

        if ( HandleLeftRightNaviKeyL( aKeyEvent, aType ) == EKeyWasConsumed )

            {

            PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL left/right navi") );    

            return EKeyWasConsumed;

            }

        }

    else

        {