/*

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

*/

// INCLUDE FILES

#include <eikbtgpc.h>

#include <eikmenub.h>

#include <musresourceproperties.h>

#include <cameraplatpskeys.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <akntoolbar.h>

#include <akntoolbarextension.h>

#include <aknbutton.h>

#include <eiksoftkeypostingtransparency.h>

#include <AknsUtils.h>

#include <gulicon.h>

#include "Cam.hrh"

#include "CamAppUi.h"

#include "CamUtility.h"

#include "CamAppController.h"

#include "CamPreCaptureContainerBase.h"

#include "CamLogger.h"

#include "CamPanic.h"

#include "CamCaptureSetupMenu.h"

#include "CamStandbyContainer.h"

#include "CamSelfTimer.h"

#include "CamTimer.h"

#include "camactivepalettehandler.h"

#include "CamPreCaptureViewBase.h"

#include "CameraUiConfigManager.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamPreCaptureViewBaseTraces.h"

#endif

// ===========================================================================

// Constants

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

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

// CCamPreCaptureViewBase destructor

// 

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

//

CCamPreCaptureViewBase::~CCamPreCaptureViewBase()

  {

  PRINT( _L("Camera => ~CCamPreCaptureViewBase") );

  PRINT( _L("Camera <= ~CCamPreCaptureViewBase") );

  }

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

// CCamPreCaptureViewBase::HandleCommandL

// Handle commands

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

//

void CCamPreCaptureViewBase::HandleCommandL( TInt aCommand )

    {

    PRINT( _L("Camera => CCamPreCaptureViewBase::HandleCommandL") );

    iLastMovement = 0;

    switch ( aCommand )

        {              

        case ECamCmdShootSetup:

            {

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

            TBool selfTimerEnabled = appUi->SelfTimerEnabled();

            if ( selfTimerEnabled )

                {                

                CCamSelfTimer* selftimer = appUi->SelfTimer();

                // If self-timer is enabled, we need to check that it is in

                // self-timer standby, ie Enabled but not Active (ie not 

                // counting down)

                if ( selftimer && !selftimer->IsActive() )

                    {

                    // In self-timer standby, pressing "select" button starts 

                    // self-timer count down.  Pass this event on to AppUi.

                    appUi->HandleCommandL( ECamCmdSelfTimerActivate );

                    }

                }

            else 

                {

                // we are not in self -timer mode and check we are

                // not already in capture setup mode

                if ( !iCaptureSetupMenuModeActive )

                    {

                    // Ensure first item is selected in CSM.

                    iCaptureSetupMenuLastItemIndex = 0;

                    SwitchToCaptureSetupMenuModeL();

                    }

                }            

            }

            break;

        // If an item in the capture setup menu has been selected.

        case EAknSoftkeySelect:  

            {

            if ( ActiveSettingMode() == ECamSettingModeCaptureMenu )

                {

                iCaptureSetupMenuContainer->HandleCommandL( aCommand );

                }

            else

                {          

                CCamCaptureSetupViewBase::HandleCommandL( aCommand );             

                }

            }

            break;

        // If capture setup menu is active and user presses softkey back,

        //  deactivate the menu. This is EEikBidCancel which has the same

        //  enumeration value as EAknSoftkeyCancel.

        case EAknSoftkeyCancel:

            {            

            if ( ActiveSettingMode() == ECamSettingModeCaptureMenu )

                {

                ExitCaptureSetupMenuModeL();

                }

            else if ( iController.SequenceCaptureInProgress() )                         

                // Check if currently capturing a burst, if so, cancel it

                {

                // If already received all the snapshots

                if ( iController.AllSnapshotsReceived() ) 

                    {

                    // stop burst immediately

                    iController.StopSequenceCaptureL();

                    }

                else

                    {

                    // capture the min images (2), before stopping the burst

                    iController.SetKeyUp( ETrue );

                    iController.SoftStopBurstL( ETrue );

                    }

                // Update CBA for setup pane usage

                SetSoftKeysL( R_CAM_SOFTKEYS_BLANK ); 

                }     

            else

                {

                CCamCaptureSetupViewBase::HandleCommandL( aCommand );                                                                                       

                }                        

            }

            break;

        case EAknSoftkeyOptions:

            {

            // do nothing, the command is handled by the framework

            }

            break;

        // Note: CaptureSetupMenu mode also uses a 'Back' softkey but this has

        // the command value EEikBidCancel            

        case EAknSoftkeyBack:

            {                                          

            // exit to embedded app if we're embedded and in plain pre-capture

            if ( iEmbedded 

                && ActiveSettingMode() != ECamSettingModeScene 

                && ActiveSettingMode() != ECamSettingModeInfoListBox )

                {

                CCamCaptureSetupViewBase::HandleCommandL( ECamCmdInternalExit );

                }

            else

                {

                CCamCaptureSetupViewBase::HandleCommandL( aCommand );              

                }                           

            }

            break;

        case EAknSoftkeyOk:

            {                                                                

                // Else pass on to lower levels

                CCamCaptureSetupViewBase::HandleCommandL( aCommand );                                     

            }

            break;

        case ECamCmdToggleCourtesyUI:

            {

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

            if ( appUi )

                {

                appUi->SetAlwaysDrawPreCaptureCourtesyUI( !appUi->AlwaysDrawPreCaptureCourtesyUI() );

                }

            }

            break;

       case ECamCmdPopUpMenuZoom: 

            {

            iContainer->ShowZoomPaneWithTimer();

            }     

            break;

        case ECamCmdCaptureSetupFlashStill:

            {

            iToolbarExtensionInvisible = ETrue;

           	CCamCaptureSetupViewBase::HandleCommandL( aCommand );

            }     

            break;

        case ECamCmdInternalExit:

            {

            const TCamCaptureOperation operation( 

                    iController.CurrentOperation() );

                 if ( ECamPaused == operation )

                   {

                   iController.StopVideoRecording();

                   iController.SetCaptureKeyPressedWhileImageSaving( ETrue );

                   }

            StopViewFinder();

            CCamCaptureSetupViewBase::HandleCommandL( aCommand );

            if ( iController.IsTouchScreenSupported() )

                {

                CAknToolbar* fixedToolbar = Toolbar();

                if ( fixedToolbar )

                    {

                    CAknToolbarExtension* extension = 

                        fixedToolbar->ToolbarExtension();

                    if ( extension )

                        {

                        // Reset toolbar extension button and view to closed state

                        extension->SetShown( EFalse );

                        extension->SetCurrentState( 0, EFalse );

                        }

                    }

                }

            }     

            break;

        default:

            {                                       

            CCamCaptureSetupViewBase::HandleCommandL( aCommand );                            

            }

        }

    PRINT( _L("Camera <= CCamPreCaptureViewBase::HandleCommandL") );

    }

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

// CCamPreCaptureViewBase::HandleForegroundEventL

// Handle a move to the foreground

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

//

void CCamPreCaptureViewBase::HandleForegroundEventL( TBool aForeground )

  {

  PRINT1( _L( "Camera => CCamPreCaptureViewBase::HandleForegroundEventL %d" ), aForeground );    

  iLastMovement = 0;

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

  __ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer));

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

  // coming to the foreground

  if ( aForeground )

    {

    // Ignore foregrounding if view switch to postcapture anyway in progress.

    if( appUi->TargetViewState() == ECamViewStatePostCapture

     || appUi->TargetViewState() == ECamViewStateBurstThumbnail ) {

      PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleForegroundEventL, ignored as going to postcapture") );    

      return;

    }

    if ( !( iController.UiConfigManagerPtr() && 

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

        {

        if ( !iController.IsTouchScreenSupported() )

            {

            if ( !appUi->ActivePalette() )

                {

                SetupActivePaletteL();

                }

            else

                {

                appUi->APHandler()->UpdateActivePaletteL();

                }

            }

        }

    UpdateCbaL();

    // restart idle timer in any case

     iController.StartIdleTimer();

    // If capture setup menu is active then ensure background is faded.

    if ( iCaptureSetupMenuContainer )

      {

      iCaptureSetupMenuContainer->FadeBehind( ETrue );

      }       

    // coming to the foreground from an eikon server window

    if ( iContinueInBackground )

      {

      iContinueInBackground = EFalse;

      if ( !iController.IsViewFinding()  && !iSceneSettingModeActive )

        {

      	iController.StartViewFinder();

        }

      else if( iLocationTrailConnecting )

          {

          iLocationTrailConnecting = EFalse;

          iController.StopViewFinder();

          iController.StartViewFinder();

          }

      CCamCaptureSetupViewBase::HandleForegroundEventL( aForeground );

      UpdateCbaL();

      if ( iController.CameraSwitchQueued() )

          {

          appUi->HandleCommandL( ECamCmdSwitchCamera );

          }

      PRINT( _L( "Camera <= CCamPreCaptureViewBase::HandleForegroundEventL - continuing in background" ) );            

      return;

      }

    // This only happens when the app is first launched        

    if ( !appUi->IsConstructionComplete() && 

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

      {

      iActivateToStandby = ETrue;

      if ( !iStandbyModeActive )

        {

        //iStandbyError = KErrNone;

        appUi->SetStandbyStatus( KErrNone );        

        PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: sending ECamCmdGoToStandby" ) );    

        HandleCommandL( ECamCmdGoToStandby );

        SetTitlePaneTextL();

        }            

      }

    // Register that we want to use the engine

    IncrementCameraUsers();

    if ( iController.UiConfigManagerPtr()->IsLensCoverSupported() )

        {

        if ( iController.CameraSwitchQueued() )

            {

            appUi->HandleCommandL( ECamCmdSwitchCamera );

            }

        else if ( appUi->TargetViewState() != ECamViewStatePostCapture )      

            {   

            TCamCameraMode mode = iController.CurrentMode(); 

            if ( mode == ECamControllerVideo )

                {

                iController.EnterViewfinderMode( ECamControllerVideo );

                }       

            else if( mode == ECamControllerImage && !iSceneSettingModeActive )

                {

                iController.EnterViewfinderMode( ECamControllerImage );

                }  

            }

        UpdateCbaL();

        }

      else

        {

        // Lens cover is not supported

        if ( iController.CameraSwitchQueued() )   

            {

            appUi->HandleCommandL( ECamCmdSwitchCamera );

            }

        }

      // Start the viewfinder unless the view is activating into standby mode

      // in other modes than scene setting mode (there is no VF and this causes problems with DSA VF)

      if ( ( !iStandbyModeActive || !iActivateToStandby )  && !iSceneSettingModeActive )

        {

        // If in embedded mode and image has been captured but view is not yet in

        // postcapture view VF should not be started.

        if( !iAssumePostCaptureView ) 

            {

            PRINT( _L("Camera <> CCamPreCaptureViewBase::HandleForegroundEventL start VF"))

            StartViewFinder();

            }

        }

    // Check if currently selected storagemedia has available memory for next capturing

    appUi->CheckMemoryAvailableForCapturing();                                   

    // <CAMERAAPP_CAPI_V2_MIGRATION/>

    // if ( iController.EngineState() == ECamEngineStillCapturePrepared ||

    //      iController.EngineState() == ECamEngineVideoCapturePrepared )

    // if ( ( ECamImageOn|ECamVideoOn )& ( iController.CameraState() ) )

    TCamCameraState state = iController.CameraState();

    if( ECamCameraPreparedImage == state ||

        ECamCameraPreparedVideo == state )     

      {

      // Now that the view is initialised, we may need to put up the

      // mmc removal note. Perform this is required.

      appUi->ShowMMCRemovalNoteIfRequiredL();                        

      if ( appUi && !iSceneSettingModeActive &&

           !( iController.UiConfigManagerPtr() && 

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

        {

        appUi->RaisePreCaptureCourtesyUI(ETrue);

        }

      }

    }

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

  // Going to the background

  else 

      {

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

      // Not behind an eikon/avkon server window

	  // or keylock on when camera needs to be released.

      TBool totalBackground = ETrue;

      if ( iController.IsAppUiAvailable() && !iController.IsKeyLockOn() )

          {

          totalBackground    = appUi->AppInBackground( EFalse );

          }

      // Either in foreground (moving to another view of our's)

      // or if in background, then not just behind a notifier dialog.

      if ( totalBackground )

          {

          ReleaseResources();

          // hide the AP to avoid blinking when coming back from bg

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

            {

            appUi->SetActivePaletteVisibility( EFalse );	

            }      

          }

      // Behind a server window

      else 

          {

          iContinueInBackground = ETrue;            

          }

      // reset post capture assumption flag since post capture is not

      // used when video is stopped for usb 

      if ( iController.IsCaptureStoppedForUsb() )

          {

          iAssumePostCaptureView = EFalse;

          }

      }

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

  if ( !iStandbyModeActive )

    {

    // Inform the container of foreground state change

    PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: inform container.." ) );        

    iContainer->HandleForegroundEventL( aForeground );

    }

  else

    {

    // if in videocall, don't exit standby	

    if ( iController.InVideocallOrRinging() )

        {

        iActivateToStandby = EFalse;

        }

    else    		

        {   	

        // If the view has been set to standby at activation then

        // the first foreground event should not be used to exit standby

        if ( !iActivateToStandby )

           {

           // inform standby container

           PRINT( _L( "Camera <> CCamPreCaptureViewBase::HandleForegroundEventL: inform standby container.." ) );        

           iStandbyContainer->HandleForegroundEventL( aForeground );

           }  

        else

           {

           iActivateToStandby = EFalse;

           }

        }

    }

         CCamCaptureSetupViewBase::HandleForegroundEventL( aForeground );

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

  }

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

// CCamPreCaptureViewBase::SetLocationTrailConnecting

// Set iLocationTrailConnecting flag.

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

//

void CCamPreCaptureViewBase::SetLocationTrailConnecting()

    {

    iLocationTrailConnecting = ETrue;

    }

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

// CCamPreCaptureViewBase::SetPostCaptureViewAsumption

// Set iAssumePostCaptureView flag.

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

//

void CCamPreCaptureViewBase::SetPostCaptureViewAsumption( TBool aAssumePostCaptureView )

    {

    iAssumePostCaptureView = aAssumePostCaptureView;

    }

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

// CCamPreCaptureViewBase::HandleControllerEventL

// Handle controller events

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

//

void CCamPreCaptureViewBase::HandleControllerEventL( TCamControllerEvent aEvent, 

                                                     TInt /*aError*/ )

  {

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

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

  switch( aEvent )

    { 

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

    case ECamEventEngineStateChanged:

      {

      // Do not do softkey update if we are already exiting

      // (AppUi is not available)