/*

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

#include <akntoolbar.h>

#include <akntoolbarextension.h>

#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"

#include "camstartuplogo.h"

#include "camvfgridinterface.h"

#include "camlinevfgriddrawer.h"

#include "camcapturebuttoncontainer.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 

const TInt KIndicatorBlinkDelay = 250 * 1000;

const TInt KNumberOfBlinks = 3;

const TInt KNumberOfBlinksVideo = 7;

const TSize  KCaptureButtonSize( 50, 50 );

const TSize  KAdditionalArea( 25, 9 );

const TInt32 KCaptureButtonYDelta( 10 );

// Snapshot data is needed in timelapse mode

const TUint KCameraEventInterest = ( ECamCameraEventClassVfControl      

                                   | ECamCameraEventClassVfData 

                                   | ECamCameraEventClassSsData 

                                   );

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

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

// CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase

// Destructor

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

//

CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase()

  {

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

  if( iCaptureButtonContainer )

      {

      delete iCaptureButtonContainer;

      }

  iController.ViewfinderWindowDeleted( &Window() );

  iController.RemoveSettingsObserver  ( this );

  iController.RemoveCameraObserver    ( this );

  iController.RemoveControllerObserver( this );    

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

    {    

    iZoomTimer->Cancel();

    }

  delete iZoomTimer;

  delete iVfGridDrawer;

  delete iStartupLogo;

  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;

  if( iIndBlinkTimer ) 

    {

    if( iIndBlinkTimer->IsActive() )

      {

      iIndBlinkTimer->Cancel();

      }

    delete iIndBlinkTimer;

    iIndBlinkTimer = NULL;

    }

  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();

  if (appUi->StartupLogoController())

    {

    TRAP_IGNORE(iStartupLogo = CCamStartupLogo::NewL(*appUi->StartupLogoController(), aRect));

    }

  // Capture button container  

  if ( iController.UiConfigManagerPtr()->IsCustomCaptureButtonSupported() &&

       iController.IsTouchScreenSupported() )

      {

      TRect rect = Rect();

      TPoint center( rect.Center() );

      TRect captureRect;

      captureRect.SetRect( center.iX   - KCaptureButtonSize.iWidth/2,

                           rect.iBr.iY - KCaptureButtonSize.iHeight - KCaptureButtonYDelta, 

                           center.iX   + KCaptureButtonSize.iWidth/2,

                           rect.iBr.iY - KCaptureButtonYDelta  );

      captureRect.Grow( KAdditionalArea );

      TCamCameraMode mode = ECamControllerImage;

      if ( iView.Id() == TUid::Uid( ECamViewIdVideoPreCapture ) )

          {

          mode = ECamControllerVideo;

          }

      iCaptureButtonContainer = CCamCaptureButtonContainer::NewL( iController, iView, 

                                                                  *this, captureRect, 

                                                                  mode );

      }

  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, DUP7_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHUTTER_RELEASE_LAG 1" );

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

        if ( iFocusState != EFocusStateFocusing )

            {

            OstTrace0( CAMERAAPP_PERFORMANCE, CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );   //CCORAPP_SHOT_TO_SNAPSHOT_START

            OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );  //CCORAPP_PRI_SHOT_TO_SNAPSHOT_START

            OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SAVE 1" );  //CCORAPP_PRI_SHOT_TO_SAVE_START

            OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SHOT 1" );  //CCORAPP_PRI_SHOT_TO_SHOT_START

            OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_SHOT_TO_STILL 1" ); //CCORAPP_SHOT_TO_STILL_START

            OstTrace0( CAMERAAPP_PERFORMANCE, DUP6_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SERIAL_SHOOTING 1" );   //CCORAPP_PRI_SERIAL_SHOOTING_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

    // and if toolbar extension is not visible