/*

* 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:  Still image pre-capture view class for Camera application*

*/

// INCLUDE FILES

#include "CamAppUi.h"

#include "CamAppController.h"

#include "CamStillPreCaptureView.h"

#include "CamLogger.h"

#include "CamUtility.h"

#include "CamContainerBase.h"

#include "CamAppUiBase.h"

#include <eikmenub.h>

#include <eikapp.h>

#include <avkon.rsg>

#include "CamCaptureSetupMenu.h"

#include "CamPanic.h"

#include "Cam.hrh"

#include "CamAppUid.h"

#include <csxhelp/lcam.hlp.hrh>

#include "CamShootingModeContainer.h"

#include "CamInfoListBoxContainer.h"

#include "CamStillPreCaptureContainer.h"

#include "CamSelfTimer.h"

#include "CamTimeLapseUtility.h"

#include <CaeEngine.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <akntoolbar.h>

#include <akntoolbarextension.h>

#include <aknbutton.h>

#include <AknsUtils.h>

#include <cameraapp.mbg>

#include <AknIconUtils.h>

#include "StringLoader.h"

#include "camactivepalettehandler.h"

#include "CameraUiConfigManager.h"

#include "CamLocalViewIds.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamStillPreCaptureViewTraces.h"

#endif

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

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

// CCamStillPreCaptureView::NewLC

// Symbian OS two-phased constructor

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

//

CCamStillPreCaptureView* CCamStillPreCaptureView::NewLC( CCamAppController& aController )

    {

    CCamStillPreCaptureView* self = 

        new( ELeave ) CCamStillPreCaptureView( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCamStillPreCaptureView destructor

// 

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

//

CCamStillPreCaptureView::~CCamStillPreCaptureView()

  {

  }

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

// CCamStillPreCaptureView::Id

// Returns UID of view

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

//

TUid CCamStillPreCaptureView::Id() const

    {

   	return TUid::Uid( ECamViewIdStillPreCapture );	

    }

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

// CCamStillPreCaptureView::DoDeactivate

// Deactivate this view

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

//

void CCamStillPreCaptureView::DoDeactivate()

    {

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMSTILLPRECAPTUREVIEW_DODEACTIVATE, "e_CCamStillPreCaptureView_DoDeactivate 1" );

    PERF_EVENT_START_L2( EPerfEventStillPreCaptureViewDeactivation );    

    PRINT( _L("Camera => CCamStillPreCaptureView::DoDeactivate" ) )

    CCamPreCaptureViewBase::DoDeactivate();

    PERF_EVENT_END_L2( EPerfEventStillPreCaptureViewDeactivation );

    PRINT( _L("Camera <= CCamStillPreCaptureView::DoDeactivate" ) )

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMSTILLPRECAPTUREVIEW_DODEACTIVATE, "e_CCamStillPreCaptureView_DoDeactivate 0" );

    }

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

// CCamStillPreCaptureView::HandleCommandL

// Handle commands

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

//

void CCamStillPreCaptureView::HandleCommandL( TInt aCommand )

    {

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

    TCamOrientation orientation = appUi->CamOrientation();

    switch ( aCommand )

        {

        case ECamMSKCmdSelect:

        case ECamMSKCmdAppCapture:

        	{

        	if( orientation == ECamOrientationCamcorder || 

        	    orientation == ECamOrientationCamcorderLeft ||

				orientation == ECamOrientationPortrait )

        		{

    		    if ( !StartMskCaptureL() )

        		    {

            		// If in the Landscape mode, MSK event is mapped 

            	  	// like a normal selection key so that AP items

            	  	// are selected and respective setting pages are launched

            	    TKeyEvent aKeyEvent;

    	    		aKeyEvent.iCode =  aKeyEvent.iRepeats = aKeyEvent.iModifiers = 0;

        			aKeyEvent.iScanCode = EStdKeyDevice3;

            		static_cast<CCamStillPreCaptureContainer*>

            				( Container() )->OfferKeyEventL( aKeyEvent, EEventKey );	

        		    }

            	}

            else if ( aCommand == ECamMSKCmdAppCapture )

               // if the Camera in the Portrait mode

          	   // MSK event is handled like a capture key

          		{

          		OstTrace0( CAMERAAPP_PERFORMANCE, DUP8_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHUTTER_RELEASE_LAG 1" );

          		if ( iController.IsViewFinding() && appUi->CheckMemoryL() )

                	{

                    OstTrace0( CAMERAAPP_PERFORMANCE, CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SAVE 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SHOT 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_SHOT_TO_STILL 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_CAPTURE_START 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP6_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SERIAL_SHOOTING 1" );

                	SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

                	iController.Capture();

                	}

          		}

            break;

        	}

        case ECamCmdCaptureImage:

            {

      	    OstTrace0( CAMERAAPP_PERFORMANCE, DUP10_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHUTTER_RELEASE_LAG 1" );

      	    if ( iController.IsViewFinding() && appUi->CheckMemoryL() &&

                !iController.CaptureModeTransitionInProgress() &&

                !iController.IsProcessingCapture() ) 

            	{

            	SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

            	// fixed toolbar is used only with touch devices

            	if ( iController.IsTouchScreenSupported() )

            	    {

                    CAknToolbar* fixedToolbar = Toolbar();

                    if ( fixedToolbar )

                        {

                        fixedToolbar->SetToolbarVisibility( EFalse );

                        }

            	    }

                // Start the autofocus operation now, the capture will be queued

                // after focus completes

                if ( !appUi->SelfTimerEnabled() 

                    && iController.ActiveCamera() != ECamActiveCameraSecondary

                    && iController.UiConfigManagerPtr()

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

                    && !iController.CurrentSceneHasForcedFocus() )

                    {

                    // Next trace should be just before "e_CAM_PRI_SHUTTER_RELEASE_LAG 1", but only when AF is supported

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP9_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_AF_LOCK 1" );

                    if( iController.CurrentOperation() == ECamNoOperation )

                        {

                        iController.SetAfNeeded( ETrue );

                        }    

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP7_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_AF 1" );

                    iController.StartAutoFocus();

                    }

                else // AF not needed, capture will start next

                    {

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP11_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP12_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP13_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SAVE 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP14_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SHOT_TO_SHOT 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP15_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_SHOT_TO_STILL 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP16_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_APP_CAPTURE_START 1" );

                    OstTrace0( CAMERAAPP_PERFORMANCE, DUP17_CCAMSTILLPRECAPTUREVIEW_HANDLECOMMANDL, "e_CAM_PRI_SERIAL_SHOOTING 1" );

                    }

            	TKeyEvent keyEvent;

            	appUi->StartCaptureL( keyEvent );

            	}

            break;

            }

        case ECamCmdTimeLapseSlider:

            {               

            TCamTimeLapse settingValue = ECamTimeLapseOff;

            if ( appUi && !appUi->IsBurstEnabled() )

                {

                settingValue = ECamTimeLapseMin;

                }                        

            TInt command = CamTimeLapseUtility::EnumToCommand( settingValue ); 

            TTimeIntervalMicroSeconds interval = CamTimeLapseUtility::EnumToInterval( settingValue );  

            // Update the current mode (single/burst/timelapse)

            if( appUi )

                {

                TRAP_IGNORE( appUi->HandleCommandL( command ) );                    

                }

            // Update timelapse interval

            iController.SetTimeLapseInterval( interval ); 

            // stop and start the viewfinder in order to update the settings

            StopViewFinder();

            StartViewFinder();

            // fixed toolbar is used only with touch devices

            if ( iController.IsTouchScreenSupported() )

                {

                UpdateToolbarIconsL();

                }

            }     

            break;

        case ECamCmdCaptureSetupLightSensitivityStill:

        // case ECamCmdCaptureSetupLightSensitivityVideo:

        	{

        	SwitchToInfoListBoxL( EInfoListBoxModeISO );

        	}

        	break;        	

        case ECamCmdGoToStandby:

            {

            // SwitchToStandbyModeL( ECamViewIdStillPreCapture, iStandbyError );

            SwitchToStandbyModeL( ECamViewIdStillPreCapture, appUi->StandbyStatus() );

            }

            break;

        case ECamCmdExitStandby:

            {

            ExitStandbyModeL();

            }

            break;

        case ECamCmdViewfinderGrid:

            {

            // Switch grid setting

            CCamPreCaptureViewBase::HandleCommandL( aCommand );

			UpdateToolbarIconsL();

            }

            break;			

        case ECamCmdToggleFacetracking: 

            {

             // Switch facetracking setting

             CCamPreCaptureViewBase::HandleCommandL( aCommand );

             UpdateToolbarIconsL();

            break;

           }    

        default:

            {

            CCamPreCaptureViewBase::HandleCommandL( aCommand ); 

            }

        }

    }   

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

// CCamStillPreCaptureView::HandleForegroundEventL

// Handle foreground event

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

//

void 

CCamStillPreCaptureView::HandleForegroundEventL( TBool aForeground )

  {

  PRINT( _L("Camera => CCamStillPreCaptureView::HandleForegroundEventL") );

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

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

  // Foreground

  //

  // reset menu and cba as appropriate

  if( aForeground )

    {

    PRINT( _L("Camera <> CCamStillPreCaptureView::HandleForegroundEventL: to foreground") );

    PRINT1( _L("Camera <> CCamStillPreCaptureView .. Current controller operation [%s]"), KCamCaptureOperationNames[iController.CurrentOperation()] );

    PRINT1( _L("Camera <> CCamStillPreCaptureView .. Current controller mode      [%s]"), KCamModeNames[iController.CurrentMode()] );

    if( ECamViewStateStandby == appUi->CurrentViewState() )

      {

      CAknToolbar* fixedToolbar = appUi->CurrentFixedToolbar();

      if( fixedToolbar )

        {

        fixedToolbar->SetToolbarVisibility( EFalse );    

        }

      }

    if( iController.SequenceCaptureInProgress() )

      {

      PRINT( _L("Camera <= CCamStillPreCaptureView::HandleForegroundEventL: sequence capture ongoing") );

      return;

      }

    if ( appUi->IsInPretendExit() )

      {

      PRINT( _L("Camera <= CCamStillPreCaptureView::HandleForegroundEventL: app in pretend exit so not grabbing resources") )

      // The view can get a foreground event while the application is

      // actually in a pretend exit situation. This occurs when the view switch

      // was called before the exit event, but didn't complete until after the

      // exit event. In this case the view should not register an interest in

      // the engine as the application is really in the background and the resources

      // need to be released

      return;

      }

    // if foreground event is received while in videocall, go to standby with error

    if ( iController.InVideocallOrRinging() && ECamNoOperation == iController.CurrentOperation() )

        {

        ExitAllModesL();

        appUi->SetStandbyStatus( KErrInUse );

        appUi->HandleCommandL( ECamCmdGoToStandby );

        SetTitlePaneTextL();	        

        return;

        }

    // check for silent profile whenever we come to foreground, we dont need it here,

    // but we keep track of this in appcontroller.

    iController.IsProfileSilent();

    // set embedded flag here

    iEmbedded = appUi->IsEmbedded();

    // make sure CBA is correct

    UpdateCbaL();

    SetMenuBar();

    if ( iContinueInBackground && !iStandbyModeActive )

        {

        // make sure that CCamAppController is in view finder mode

        if ( iController.CurrentImageMode() == ECamImageCaptureNone )

            {

            StartViewFinder();

            }

        }

    }

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

  // Background

  //

  // If going to the background, cancel any current autofocus.

  // This makes sure that the focus indicator is removed from the side pane

  // if the key release event is lost.

  // Cancelling focus does nothing if a capture has already been requested

  else

    {

    PRINT( _L("Camera <> CCamStillPreCaptureView::HandleForegroundEventL: to background") );

    // Cancel any outstanding capture

    iController.CancelFocusAndCapture();

    // stop any current sequence capture unless it is only a notification

    if( iController.SequenceCaptureInProgress() 

     && ( appUi->AppInBackground( EFalse ) 

       || appUi->ForegroundAppIsPhoneApp()

        )

      )

      {

      iController.StopSequenceCaptureL();

      }

     /*

    // stop any current sequence capture unless it is only an eikon server or AknCapServer window

    if ( iCoeEnv->WsSession().GetFocusWindowGroup() != iEikonServerWindowGroupId

        && iController.SequenceCaptureInProgress() )

      {

      TInt groupId = iCoeEnv->WsSession().GetFocusWindowGroup();

      if ( !CamUtility::IdMatchesName( groupId, KAknCapServer ) )

        {

        // If AknCapServer has NOT got foreground, (which would possibly 

        // indicate a "charging" note) stop sequence capture

        iController.StopSequenceCaptureL();

        }

      }

    */

    }

  CCamPreCaptureViewBase::HandleForegroundEventL( aForeground );

  PRINT( _L("Camera <= CCamStillPreCaptureView::HandleForegroundEventL") );

  }

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

// CCamStillPreCaptureView::HandleFocusLossL

// Handle change of focus

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

//

void CCamStillPreCaptureView::HandleFocusLossL()

    {

    PRINT( _L( "Camera => CCamStillPreCaptureView::HandleFocusLossL" ) );    

    // if the application was already in the background, but behind an

    // eikon server window, then handle backgrounding properly now.

    // Otherwise the backgrounding will be handled in the normal

    // HandleForeground() method.

    if ( iContinueInBackground )

        {

        if ( iController.SequenceCaptureInProgress() )

            {

            iController.StopSequenceCaptureL();

            }

        }

    CCamPreCaptureViewBase::HandleFocusLossL();

    }    

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

// CCamStillPreCaptureView::HandleControllerEventL

// Handle controller events

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

//

void CCamStillPreCaptureView::HandleControllerEventL( TCamControllerEvent aEvent, 

                                                     TInt aError )

    {

    PRINT( _L("Camera => CCamStillPreCaptureView::HandleControllerEventL") );

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

    if ( ECamEventControllerReady == aEvent )

            {

            iSoftkeyBlankIsNeeded = EFalse;

            UpdateCbaL();

            }

            else if ( aEvent == ECamEventOperationStateChanged )

        {

        PRINT( _L("Camera <> CCamStillPreCaptureView: ECamEventOperationStateChanged") );

        TCamCaptureOperation operation = iController.CurrentOperation();

        switch ( operation )

            {

            case ECamCompleting:

                {

                UpdateCbaL();

                break;

                }

            case ECamFocusing:

                {

                // Hide the AP during focussing

                if ( appUi->AlwaysDrawPreCaptureCourtesyUI()

                    && !iController.CurrentSceneHasForcedFocus() )

                    {

                    appUi->SetActivePaletteVisibility( EFalse );

                    }

                break;

                }

            case ECamFocused:

                {

                // Hide the AP during focussing

                if ( appUi->AlwaysDrawPreCaptureCourtesyUI()

                    && !iController.CurrentSceneHasForcedFocus() )

                    {

                    appUi->SetActivePaletteVisibility( EFalse );

                    }

                UpdateCbaL();

                break;

                }                

            case ECamNoOperation:

                {

                if( iController.IsAppUiAvailable() )

	                {

	                //Update softkey state.

	                UpdateCbaL();

	                // Hide the AP if we already have an autofocus request but operation doesn't

	                // have it (likely shutter was half-pressed before precap view opened)

	                if ( iController.PendingAFRequest() != 0 && 

	                     appUi->AlwaysDrawPreCaptureCourtesyUI() &&

	                     !iController.CurrentSceneHasForcedFocus() )

	                    {

	                    appUi->SetActivePaletteVisibility( EFalse );

	                    UpdateCbaL();

	                    }

	                // Show the AP again if the shutter key is released

	                // without taking a picture, don't show if uiorientationoverride

	                // feature is on and VF not running (prevents AP flashing in startup)

	                if ( iPreviousControllerOperation !=ECamStandby &&

	                     appUi->CurrentViewState() == ECamViewStatePreCapture && 

	                     appUi->AlwaysDrawPreCaptureCourtesyUI() && 

	                     !iSceneSettingModeActive && 

	                     !( iController.UiConfigManagerPtr() && 

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

	                     !iController.IsViewFinding() ) ) 

	                    {

	                    appUi->SetActivePaletteVisibility( ETrue );

                        }

                    }

                break;

                }