/*

* 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:  App UI class for cameraapp

*

*/

// This needs to be included first, because other include files

// may be variated using these flags.

#include <avkon.hrh>

#include <barsread.h>  // TResourceReader

#include <StringLoader.h>

#include <sysutil.h>

#include <eikenv.h>

#include <hlplch.h>

#include <apgwgnam.h>

#include <apgcli.h>

#include <DocumentHandler.h>

#include <apmstd.h>

#include <textresolver.h>

#include <aknnotewrappers.h>

#include <akntitle.h>  // CAknTitlePane

#include <aknclearer.h>

#include <aknnavide.h>

#include <AknWaitDialog.h>

#include <aknstaticnotedialog.h>

#include <AknCapServerDefs.h>

#include <akntoolbar.h>

#include <aknstyluspopupmenu.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <akntoolbarextension.h>

#include <eiksoftkeypostingtransparency.h>

#include <centralrepository.h>

#include <AknSgcc.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <activepalette2ui.h>

#include <AknGlobalNote.h>

#include <hal.h>

#include <hal_data.h>

#include <oommonitorsession.h>

#include <driveinfo.h>

#include <pathinfo.h>

#include <AccMonitor.h>

#ifndef __WINSCW__

//#include <SFIUtilsAppInterface.h>

#endif

#include <musresourceproperties.h>

#include <cameraplatpskeys.h>

#include <AknCommonDialogsDynMem.h>

#include <CAknMemorySelectionDialogMultiDrive.h>

#include <aknmessagequerydialog.h>

#include "CameraappPrivateCRKeys.h"

#include "CamAppUi.h"

#include "CamUtility.h"

#include "CamAppController.h"

#include "CamControllerObservers.h"

#include "CamTimer.h"

#include "CamLogger.h"

#include "CamStillPreCaptureView.h"

#include "CamStillPostCaptureView.h"

#include "CamVideoPreCaptureView.h"

#include "CamVideoPostCaptureView.h"

#include "CamBurstThumbnailView.h"

#include "CamSelfTimer.h"

#include "CamPanic.h"

#include "CamBurstModeObserver.h"

#include "CamStillUserSceneSetupView.h"

#include "CamNaviCounterControl.h"

#include "CamNaviCounterModel.h"

#include "CamNaviProgressBarControl.h"

#include "Cam.hrh"

#include "CamSettings.hrh"

#include "CamProductSpecificSettings.hrh"

#include "CamAppUiBase.h"

#include "CamWaitDialog.h"

#include "CamSidePane.h"

#include "CamZoomPane.h"

#include "CamAppUid.h"

#include <csxhelp/lcam.hlp.hrh>

#include "CameraVariant.hrh"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamAppuiTraces.h"

#endif

#include "camactivepalettehandler.h"

#include "CamContainerBase.h"

#include "camuidconstants.h"

#include "CamGSInterface.h"

#include "CamFileCheckAo.h"

#include "CamLocalViewIds.h"

#include "CameraUiConfigManager.h"

#include "MCamAddToAlbumObserver.h"

#include "CamCollectionManagerAo.h"

#include "glxgallery.hrh"

#include "glxcollectionplugincamera.hrh"

#include "s32mem.h"

#include "camflashstatus.h"

#include "CamMemoryMonitor.h"

#include "camstartuplogocontroller.h"

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

// Constants

// Sequence mode related constants that define the amount of pictures taken

// with sequence mode.

const TInt KShortBurstCount  = 18;   // number of images captured during burst

// When asked if current memory is full in video mode

// there needs to be at least following amount of recording

// time left or memory is said to be full.

const TTimeIntervalMicroSeconds KMemoryFullVideoRemaining = 1000*1000;

// This is used to find the window group id for Eikon Server.

// The Eikon Server window group id is later used to ignore all window server

// events saying Eikon Server has gained focus.

_LIT( KEikonServer, "EikonServer" );

_LIT8(K3gpVideoMimeType, "video/3gpp");

_LIT8(KMp4VideoMimeType, "video/mp4");

//const TCamMediaStorage KCamInternalStorage = ECamMediaStoragePhone;

const TUint KCameraEventInterest = ( ECamCameraEventClassBasicControl

                                   | ECamCameraEventClassImage

                                   | ECamCameraEventClassVideo

                                   | ECamCameraEventClassVfControl

                                   | ECamCameraEventClassSsControl

                                   | ECamCameraEventClassSettings );

/**

 * class CCamFtuDisplay

 * This class is used to give a notification to Camera First Time User regarding the 

 * geotagging of captured images or videos.

 */

class CCamFtuDisplay : public CAsyncOneShot 

    {

public:

    /**

     * CCamFtuDisplay

     * Default Constructor

     */

    CCamFtuDisplay( CCamAppUi * aCamAppUi )

    : CAsyncOneShot( CActive::EPriorityLow), iCamAppUi(aCamAppUi)

            {

            }

    enum TEnableCamFtu

        {

        ECamFtuEnable = 0,

        ECamFtuDisable

        };

protected:

    /**

     * RunL

     * Callback method

     */

    void RunL()

        {

        iCamAppUi->CamFtuDisplayL();

        }

private:

    /**

     * iCamAppUi

     * An instance of the CCamAppUi

     */

    CCamAppUi* iCamAppUi;

    };

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

// Member functions

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

// CCamAppUi::~CCamAppUi

// Destructor

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

//

CCamAppUi::~CCamAppUi()

    {

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

    if ( iMemoryMonitor )

        {

        iMemoryMonitor->StopMonitoring();

        delete iMemoryMonitor;

        iMemoryMonitor = 0;

        }

    delete iStartupLogoController;

    iController.SetAppUiAvailable( EFalse );

    iResourceLoaders.Close();

#ifdef CAMERAAPP_DELAYED_POSTCAPTURE_CREATION

    if( iPostCapIdle )

        {

        iPostCapIdle->Cancel();

        delete iPostCapIdle;

        }

#endif

    if ( iFileCheckAo )

        {

        iFileCheckAo->Cancel();

        delete iFileCheckAo;	

        }

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

         iSensorIdle )

        {

        CancelSensorIdle();

        delete iSensorIdle;

        }  

#if !defined(__WINSCW__)

    // relinquish capture keys

    UnRegisterCaptureKeys();    

#endif

    SaveCaptureMode();

    SaveCourtesyUiState();

    delete iDecoratedNaviPaneCounter;

    delete iDecoratedNaviPaneProgressBar;

#if defined( CAMERAAPP_CAPI_V2_DVF )

    if ( iSelfTimer )

        {

        iSelfTimer->RemoveObserver( this );

        }

#endif // CAMERAAPP_CAPI_V2_DVF

    delete iSelfTimer;

    delete iParentAppName;

    delete iTextResolver;

    iController.RemoveControllerObserver( this );

    // Burst mode observers are not owned, delete only the pointers to them.

    iBurstModeObservers.Close();

    if ( iWaitTimer && iWaitTimer->IsActive() )

        {

        iWaitTimer->Cancel();

        }

    delete iWaitTimer;

    delete iDocHandler;

    delete iCamSidePane;

    delete iCamZoomPane;       

    delete iRepository;

/*#ifndef __WINSCW__

    delete iSFIUtils;

#endif*/

    delete iNaviCounterControl;

    delete iNaviProgressBarControl;

    delete iNaviCounterModel;

    delete iNaviProgressBarModel;  

    delete iActivePaletteHandler;

    iActivePaletteHandler = NULL;

    if( iCourtesyTimer )

        {

        iCourtesyTimer->Cancel();

        }

    delete iCourtesyTimer;

    delete iScreenClearer;

    delete iVolumeKeyObserver;

    delete iCollectionManager;

    iCollectionManager = NULL;

    if( iCamFtuDisplay )

        {

        delete iCamFtuDisplay;

        iCamFtuDisplay = NULL;

        }

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

    }

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

// CCamAppUi::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCamAppUi::ConstructL()

  {

  OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP2_CCAMAPPUI_CONSTRUCTL, "e_CCamAppUi_ConstructL 1" );

  PRINT( _L("Camera => CCamAppUi::ConstructL") )

  iRotatedKeyEvent = ETrue;

  iReturnedFromPlugin = EFalse;

  iController.SetAppUiAvailable( ETrue );

  iLockedQwertyState = E2ndCamUnknown; 

  iMemoryMonitor = CCamMemoryMonitor::NewL( this, &iController );

  TInt memError =

  iMemoryMonitor->CheckAndRequestMemoryL( iController.UiConfigManagerPtr()->CriticalLevelRamMemory(),

                                          iController.UiConfigManagerPtr()->RequiredRamMemory(),

                                          ETrue );

  TInt freeMemory = 0;

  HAL::Get( HALData::EMemoryRAMFree, freeMemory );

  if ( memError && freeMemory < iController.UiConfigManagerPtr()->CriticalLevelRamMemoryFocusGained() )

      {

      User::Leave( memError );

      }

  iUiConstructionComplete = EFalse;

  iDSASupported = iController.UiConfigManagerPtr()->IsDSAViewFinderSupported();

  TBool uiOrientationOverride = iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported();

  // Get the screenmode values used for setting  the orientation

  if ( uiOrientationOverride )

      {

      RArray<TInt> screenModeValues;

      CleanupClosePushL( screenModeValues );

      iController.UiConfigManagerPtr()->SupportedScreenModesL( screenModeValues );

      iLandscapeScreenMode = screenModeValues[0];

      iPortraitScreenMode = screenModeValues[1];

      CleanupStack::PopAndDestroy( &screenModeValues );

      }

  // The embedded views are set after ConstructL completes

  // but the value is only of interest if the app is embedded

  iEmbeddedViewSet = !IsEmbedded();

  PRINT1( _L("Camera => CCamAppUi::ConstructL iEmbeddedViewSet:%d"), iEmbeddedViewSet );

  // In embedded case requesting new file without defined resolution

  // the 0*0 is interpreted as the default mms size resolution

  iRequestedNewFileResolution.SetSize( 0, 0 );

  // Camera window group id

  iMyWgId = iCoeEnv->RootWin().Identifier();

  // Get the id of Eikon Server window group

  iEikonServerWindowGroupId = iCoeEnv->WsSession().FindWindowGroupIdentifier(

    0,

    KEikonServer );

  CApaWindowGroupName::FindByAppUid(

    KBtNotifierServerUid,

    iCoeEnv->WsSession(),

    iBTServerWindowGroupId);

  CApaWindowGroupName::FindByAppUid(

    KPhoneAppUid,

    iCoeEnv->WsSession(),

    iPhoneAppWindowGroupId);

  PRINT( _L("Camera <> create new repository") );

  TInt crValue = 0;

  if( !iRepository )

    {

    iRepository = CRepository::NewL( KCRUidCameraappSettings ); 

    }

  // get softkey position

  CamUtility::GetPsiInt( ECamPsiSoftKeyPosition, iSoftkeyPosition );

  iCamOrientation = ReadCurrentDeviceOrientation();

  PRINT1( _L("Camera <> CurrentDeviceOrientation (%d)"), iCamOrientation )

  PERF_EVENT_START_L2( EPerfEventAvkonUIConstruction );  

  TInt orientation;

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

      {

      PRINT( _L("Camera <> using slider position to set orientation") );

      // Use the current slider position for the required orientation

      TInt sliderPosition;

      TInt err = RProperty::Get(

            CameraPlatPSKeys::KPSCameraPlatUid,

            CameraPlatPSKeys::KLensCoverStatus,

            sliderPosition );  

      // ToDo this could be removed after PCFW has released new implementation (wk25/2009)

      if( err == KErrNotFound )

          {

          PRINT( _L("Camera <> using slider position to set orientation") );

          err = RProperty::Get(

              NMusResourceApi::KCategoryUid,

              NMusResourceApi::KCameraAvailability,

              sliderPosition );  

          }

      PRINT2( _L("Camera <> slider position = %d, error = %d"),

            sliderPosition, err );

      // If there is an error then assume the slider is closed (as long as there is

      // more than one camera) 

      if ( err )

        {

        PRINT1( _L("Camera <> Slider status err%d - Check status later"),err )

        iController.SetCameraSwitchRequired( ESwitchToUnknown );

        }

      if ( ( ( CCamAppController::CamerasAvailable() > 1 && 

             sliderPosition == CameraPlatPSKeys::EClosed ) || 

           err != KErrNone ) && !IsQwerty2ndCamera( ETrue ) ) 

          {

          PRINT( _L("Camera <> setting orientation for secondary camera") )

          CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, orientation );

          }

      else

          {

          PRINT( _L("Camera <> setting orientation for primary camera") )

          CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, orientation );    

          } 

      }

  else

      {

      // Without lens cover support, always start to primary camera

      CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, orientation );

      }

  if ( orientation == ( TInt ) EAppUiOrientationLandscape )

    {

    PRINT( _L("Camera <> orientation is landscape ") )

    iCamOrientation = (ECamHandLeft == iSoftkeyPosition ) 

                    ? ECamOrientationCamcorderLeft 

                    : ECamOrientationCamcorder;

    PRINT( _L("Camera <> Calling BaseConstructL") )

    OstTrace0( CAMERAAPP_PERFORMANCE, CCAMAPPUI_CONSTRUCTL, "e_CAM_APP_BASE_CONSTRUCT 1" ); //CCORAPP_APP_BASE_CONSTRUCT_START

    BaseConstructL( EAppOrientationLandscape | EAknEnableSkin | EAknEnableMSK | 

                    ENonStandardResourceFile | EAknSingleClickCompatible );

    OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMAPPUI_CONSTRUCTL, "e_CAM_APP_BASE_CONSTRUCT 0" );    //CCORAPP_APP_BASE_CONSTRUCT_END

    PRINT( _L("Camera <> BaseConstructL Complete") )

    if( uiOrientationOverride )

      {

      // Finish engine construction

      iController.CompleteConstructionL();  

      //set orientation to CCamera	

      iController.SetCameraOrientationModeL( iLandscapeScreenMode );

      // and complete the cameracontroller construction

      iController.CompleteCameraConstructionL();

      }

    }

  else

    {

    PRINT( _L("Camera <> orientation is portrait") )

    iCamOrientation = ECamOrientationPortrait;

    PRINT( _L("Camera <> Calling BaseConstructL") )

    OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMAPPUI_CONSTRUCTL, "e_CAM_APP_BASE_CONSTRUCT 1" );

    BaseConstructL( EAppOrientationPortrait | EAknEnableSkin | EAknEnableMSK | 

                    ENonStandardResourceFile );  

    OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMAPPUI_CONSTRUCTL, "e_CAM_APP_BASE_CONSTRUCT 0" );

    PRINT( _L("Camera <> BaseConstructL Complete") )

    if( uiOrientationOverride )

      {

      // Finish engine construction

      iController.CompleteConstructionL();  

      //set orientation to CCamera	

      iController.SetCameraOrientationModeL( iPortraitScreenMode );

      // and complete the cameracontroller construction

      iController.CompleteCameraConstructionL();

      }     

    }

    PERF_EVENT_END_L2( EPerfEventAvkonUIConstruction );

#if !defined (__WINSCW__)

#if !( defined(__WINS__) || defined(__WINSCW__) )

  // Ensure that the macro switch keys are always captured by this

  // application.

  if ( !AppInBackground( EFalse ) )  //camera is constructed in background

     {

      RegisterCaptureKeysL();

     }

#endif // !defined(__WINS__) || defined(__WINSCW__)    

#endif

  if( !uiOrientationOverride )

    {

    // Load the settings model static settings

    PRINT( _L("Camera <> call CCamAppController::LoadStaticSettingsL..") )

    iController.LoadStaticSettingsL( IsEmbedded() );

    // Check the screen size if it matches the orientation we expect.

    // If not, delay the initialization until HandleScreenDeviceChangedL is called.

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP6_CCAMAPPUI_CONSTRUCTL, "e_ReadUiOrientationFromWindowServer 1" );

    TSize screenSize = iCoeEnv->ScreenDevice()->SizeInPixels();

    PRINT2( _L("<> CCamAppUi::ConstructL() iCoeEnv->ScreenDevice()->SizeInPixels():  w=%d h=%d"), screenSize.iWidth, screenSize.iHeight );

    TBool expectLandscape = (iCamOrientation != ECamOrientationPortrait);

    TBool isLandscape     = (screenSize.iWidth > screenSize.iHeight);

    if( isLandscape != expectLandscape || AppInBackground( EFalse ) )   //screen is not ready or camera app is in background

      {

      iEngineConstructionDelayed = ETrue;

      }

OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP7_CCAMAPPUI_CONSTRUCTL, "e_ReadUiOrientationFromWindowServer 0" );

    // initialise the self timer mode 

    iInSelfTimerMode = ECamSelfTimerDisabled;

    if ( !iEngineConstructionDelayed )     

      {

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP8_CCAMAPPUI_CONSTRUCTL, "e_EngineConstructionDelayed 1" );

      iController.CompleteConstructionL();

      iController.StoreUserSceneSettingsL();

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP9_CCAMAPPUI_CONSTRUCTL, "e_EngineConstructionDelayed 0" );

      }