/*

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

*/

// INCLUDE FILES

#include "CamUtility.h"

#include "CamAppUiBase.h"

#include "CamAppController.h"

#include "CamVideoPreCaptureView.h"

#include "CamLogger.h"

#include "CamContainerBase.h"

#include "CamAppUi.h"

#include <eikmenub.h>

#include <eikapp.h>

#include <avkon.rsg>

#include <CaeEngine.h>

#include <akntoolbar.h>

#include <akntoolbarextension.h>

#include <gulicon.h>

#include <AknIconUtils.h>

#include <aknbutton.h>

#include <StringLoader.h>

#include <AknsUtils.h>

#include <AknsConstants.h>

#include <cameraapp.mbg>

#include "CamCaptureSetupMenu.h"

#include "CamPanic.h"

#include "CamSidePane.h"

#include "CamShootingModeContainer.h"

#include "CamVideoPreCaptureContainer.h"

#include "Cam.hrh"

#include "CamAppUid.h"

#include <csxhelp/lcam.hlp.hrh>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include "CamUtility.h"

#include "camactivepalettehandler.h"

#include "CameraUiConfigManager.h"

#include "CamLocalViewIds.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamVideoPreCaptureViewTraces.h"

#endif

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

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

// CCamVideoPreCaptureView::NewLC

// Symbian OS two-phased constructor

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

//

CCamVideoPreCaptureView* CCamVideoPreCaptureView::NewLC( CCamAppController& aController )

    {

    CCamVideoPreCaptureView* self = 

        new( ELeave ) CCamVideoPreCaptureView( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCamVideoPreCaptureView destructor

// 

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

//

CCamVideoPreCaptureView::~CCamVideoPreCaptureView()

    {

    }

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

// CCamVideoPreCaptureView::Id

// Returns UID of view

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

//

TUid CCamVideoPreCaptureView::Id() const

    {

  	return TUid::Uid( ECamViewIdVideoPreCapture );

    }

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

// CCamVideoPreCaptureView::DoDeactivate

// Deactivate this view

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

//

void CCamVideoPreCaptureView::DoDeactivate()

    {

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMVIDEOPRECAPTUREVIEW_DODEACTIVATE, "e_CCamVideoPreCaptureView_DoDeactivate 1" );

    PERF_EVENT_START_L2( EPerfEventVideoPreCaptureViewDeactivation ); 

    CCamPreCaptureViewBase::DoDeactivate();

    PERF_EVENT_END_L2( EPerfEventVideoPreCaptureViewDeactivation ); 

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMVIDEOPRECAPTUREVIEW_DODEACTIVATE, "e_CCamVideoPreCaptureView_DoDeactivate 0" );

    }

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

// CCamVideoPreCaptureView::HandleCommandL

// Handle commands

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

//

void 

CCamVideoPreCaptureView::HandleCommandL( TInt aCommand )

  {

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

  // check our current operation state

  TCamCaptureOperation operation = iController.CurrentVideoOperation();

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

  TCamOrientation orientation = appUi->CamOrientation();

  switch ( aCommand )

    {

    case ECamMSKCmdSelect:

    case ECamMSKCmdAppRecord:

    	{

        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<CCamVideoPreCaptureContainer*>

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

       		    }

        	}

        else if ( aCommand == ECamMSKCmdAppRecord )

             // if the Camera in the Portrait mode

             // MSK event is handled like a capture key

            {

                {

                iController.StartVideoRecordingL();

                // fixed toolbar is used only with touch devices

                if ( iController.IsTouchScreenSupported() )

                    {

                    CAknToolbar* fixedToolbar = Toolbar();

                    if ( fixedToolbar )

                        {

                        fixedToolbar->SetToolbarVisibility( EFalse );

                        }

                    }

                }

            }	

        break;

    	}

    case ECamCmdRecord:

        {

        	TInt callType( EPSCTsyCallTypeUninitialized );

            RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallType, callType );

            {

            SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

            appUi->SetLensCoverExit( EFalse );

            iController.StartVideoRecordingL();

            // fixed toolbar is used only with touch devices

            if ( iController.IsTouchScreenSupported() )

                {

                CAknToolbar* fixedToolbar = Toolbar();

                if ( fixedToolbar )

                    {

                    fixedToolbar->SetToolbarVisibility( EFalse );

                    }

                }

            }

        break;

        }

    case EAknSoftkeySelect:

      {

      switch( operation )

        {

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

        case ECamNoOperation:

          {

          if ( !iController.VideoRecordPending() )

            {                    

            CCamPreCaptureViewBase::HandleCommandL( aCommand );

            }

          break;

          }

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

        // ...Otherwise, if we are in video recording or paused mode

        // ...then stop the recording.

        case ECamCapturing:

        case ECamPaused:

          {

          iController.StopVideoRecording();

          break;

          }

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

        default:

          break;

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

        }

      break;

      }

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

    case ECamCmdPause:

      {

      iController.PauseVideoRecording();

      break;

      }

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

    case ECamCmdContinue:

      {

      iController.ContinueVideoRecording();

      break;

      }

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

    case ECamCmdShootSetup:

      {

      // If currently recording or paused recording then don't

      // popup the capture setup menu.

      if ( ECamPaused     == operation 

        || ECamCapturing == operation )

        {

        return;

        }

      // Otherwise popup the capture setup menu

      else

        {

        CCamPreCaptureViewBase::HandleCommandL( aCommand );

        }

      break;

      }

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

    case ECamCmdGoToStandby:

      {

      PRINT( _L("Camera <> CCamVideoPreCaptureView::HandleCommandL: case ECamCmdGoToStandby") );

      //PRINT1( _L("Camera => CCamVideoPreCaptureView::HandleCommandL standby error (%d)"), iStandbyError)

      //SwitchToStandbyModeL( ECamViewIdVideoPreCapture, iStandbyError );

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

      break;

      }

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

    case ECamCmdExitStandby:

      {

      PRINT( _L("Camera <> CCamVideoPreCaptureView::HandleCommandL: case ECamCmdExitStandby") );

      ExitStandbyModeL();

      UpdateToolbarIconsL();

      break;

      }

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

    case ECamCmdMute:

      {

      MuteEmbeddedAudioL( ETrue );

      break;

      }

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

    case ECamCmdUnmute:

      {

      MuteEmbeddedAudioL( EFalse );

      break;

      }

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

    case ECamCmdStop:

      {

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

      appUi->EndCapture();

      break;

      }

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

    case ECamCmdToggleVideoFlash:

      {

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

          {

          TCamFlashId flash = static_cast< TCamFlashId > 

                        ( iController.IntegerSettingValue( ECamSettingItemDynamicVideoFlash ) );       

          if( flash == ECamFlashForced )

            {

            flash = ECamFlashOff;

            }

          else

            {

            flash = ECamFlashForced;

            }

          iController.SetIntegerSettingValueL(ECamSettingItemDynamicVideoFlash, flash);             

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

          if ( appUi && 

               appUi->APHandler() &&

               ( appUi->CamOrientation() == ECamOrientationCamcorder || appUi->CamOrientation() == ECamOrientationCamcorderLeft ) )

            {

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

            }          

          }

      UpdateToolbarIconsL();

      break;

      }

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

    default:

      {

      CCamPreCaptureViewBase::HandleCommandL( aCommand );

      break;

      }

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

    }

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

  }

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

// CCamVideoPreCaptureView::HandleForegroundEventL

// Handle foreground event

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

//

void 

CCamVideoPreCaptureView::HandleForegroundEventL( TBool aForeground )

  {

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

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

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

  // reset menu and cba as appropriate

  if( aForeground )

    {

    // ignore event if received in postcapture or if uiorientationoverride

    // is supported and going to stillmode

    if ( ECamViewStatePostCapture == appUi->CurrentViewState() ||

       ( iController.UiConfigManagerPtr() && 

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

         appUi->TargetMode() == ECamControllerImage ) ) 

      {

      return;	

      }	

    if ( appUi->IsInPretendExit() )

      {

      // 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

      PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleForegroundEventL, in pretend exit" ) );

      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;

        }

    // make sure CBA is correct

    UpdateCbaL();

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

    PRINT1( _L("Camera <> CCamVideoPreCaptureView::HandleForegroundEventL - iEmbedded:%d"), iEmbedded );

    // update menu bar as required

    SetMenuBar();

    // if video is currently saving, it can be in either of the states:

    // ECamVideoRecordInProgress orECamVideoRecordPaused

    // but the recording has already been stopped

    if ( iController.CurrentlySavingVideo() )

      {

      UpdateCbaL();

      // if the app was behind an eikon server window then the resources

      // were not released. 

      if ( iContinueInBackground )

        {

        iContinueInBackground = EFalse;

        PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleForegroundEvent, returned behind notification" ) );                

        return;

        }

      // Register that we want to use the engine

      IncrementCameraUsers();

      PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleForegroundEvent, waiting for postcapture" ) );                

      return;

      }

    }

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

  // if going to the background, stop any current video recording

  // unless already saving or it is only an eikon server window

  else

    {

    TCamCaptureOperation operation( iController.CurrentVideoOperation() );

    PRINT1( _L("Camera <> CCamVideoPreCaptureView::HandleForegroundEventL - operation=%d"), operation );

    if( !iController.CurrentlySavingVideo() && 

    	( ( ECamCapturing == operation || ECamPaused    == operation ) 

    	   && appUi->AppInBackground( EFalse )

    	   || ( iController.UiConfigManagerPtr()->IsKeyLockWatcherSupported() && iController.IsKeyLockOn() ) ) )

      {

        PRINT( _L("Camera <> CCamVideoPreCaptureView::HandleForegroundEventL  stopping video") );

      // If the video stops for an active call then inform the controller

      // this info is needed so that the stop tone isn't played

      if ( appUi->ForegroundAppIsPhoneApp() )

        {

        PRINT( _L("Camera <> CCamVideoPreCaptureView::HandleForegroundEventL  SetVideoStoppedForPhoneApp") );

        iController.SetVideoStoppedForPhoneApp( ETrue );

        }

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

      // indicate a "charging" note) stop video recording

      iController.StopVideoRecording();

      // reset the stopped for call flag

      iController.SetVideoStoppedForPhoneApp( EFalse );

      }

    /*

    const TInt KWindowGroupId( iCoeEnv->WsSession().GetFocusWindowGroup() );

    TCamCaptureOperation operation( iController.CurrentVideoOperation() );

    if ( KWindowGroupId != iEikonServerWindowGroupId

      && KWindowGroupId != iBTServerWindowGroupId

      && ( ECamCapturing == operation

        || ECamPaused    == operation ) )

      {

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

        {

        // If the video stops for an active call then inform the controller

        // this info is needed so that the stop tone isn't played

        if ( appUi->ForegroundAppIsPhoneApp() )

          {

          iController.SetVideoStoppedForPhoneApp( ETrue );

          }

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

        // indicate a "charging" note) stop video recording

        iController.StopVideoRecording();

        // reset the stopped for call flag

        iController.SetVideoStoppedForPhoneApp( EFalse );

        }

      }

      */

    }

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

  CCamPreCaptureViewBase::HandleForegroundEventL( aForeground );

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

  }

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

// CCamVideoPreCaptureView::HandleFocusLossL

// Handle change of focus

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

//

void CCamVideoPreCaptureView::HandleFocusLossL()

  {

  PRINT( _L( "Camera => CCamVideoPreCaptureView::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 )

    {

    const TCamCaptureOperation operation( iController.CurrentOperation() );

    if ( ECamCapturing == operation

      || ECamPaused    == operation )

      {

      iController.StopVideoRecording();

      }

    }

  CCamPreCaptureViewBase::HandleFocusLossL();

  PRINT( _L( "Camera <= CCamVideoPreCaptureView::HandleFocusLossL" ) );    

  }

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

// CCamVideoPreCaptureView::HandleControllerEventL

// Handle controller events

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

//

void CCamVideoPreCaptureView::HandleControllerEventL( TCamControllerEvent aEvent, 

                                                     TInt aError )

  {

  PRINT2( _L("Camera => CCamVideoPreCaptureView::HandleControllerEventL event (%d) error (%d)"), aEvent, aError );

  switch( aEvent )

    {

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

    // If the recording state of the camera has changed (started/paused/stopped)

    // we may need to update the CBA labels

    case ECamEventOperationStateChanged:

      {

      if( iController.IsAppUiAvailable() )