/*

* 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:  Camera Controller implementation.

*              : Class handles CCamera related operations.

*

*/

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

// Included headers

#include "camcameracontrollerflags.hrh"

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

// General

#include <e32base.h>

#include <e32const.h> // KNullHandle

#include <fbs.h>

#include <gdi.h>

#include <aknlayoutscalable_apps.cdl.h>

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

// ECAM

#include <ecam.h>

#ifdef CAMERAAPP_CAPI_V2

  #include <ecam/ecamdirectviewfinder.h>

  #include <ecam/camerahistogram.h>

  #include <ecam/cameraoverlay.h>

  #include <ecamadvsettings.h>

  #include <ecamadvsettingsuids.hrh>

#endif

#include <ecam/camerasnapshot.h> // KUidECamEventCameraSnapshot

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

// Camera Application Engine (CAE)

#ifdef CAMERAAPP_CAE_FOR_VIDEO

  #include <CaeEngine.h>

#endif

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

// Custom interfaces

#include <ECamOrientationCustomInterface2.h>

#include <ECamUIOrientationOverrideCustomAPI.h>

#include <ecamfacetrackingcustomapi.h>

#include <akntoolbar.h> 

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

// Own

#include "camcameracontroller.pan"

#include "camlogging.h"

#include "cambuffershare.h"

#include "cambuffersharecleanup.h"

#include "cambuffercleanup.h"

#include "cambuffer.h"  

#include "camsnapshotprovider.h"

#include "camimageencoder.h"

#include "mcamsettingprovider.h"

#include "mcamcameraobserver.h"

#include "camsettingconversion.h"

#include "camcameraevents.h"

#include "camcamerarequests.h"

#include "camcameracontrolleractive.h"

#include "camcameracontroller.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "camcameracontrollerTraces.h"

#endif

#ifdef FORCE_DUMMY_ENGINE

  #include "CameraappDummyEngine.h"

#endif // FORCE_DUMMY_ENGINE

#ifdef CAMERAAPP_CAPI_EMULATOR

  #include "CamCamera.h"

#endif // CAMERAAPP_CAPI_EMULATOR

#ifdef CAMERAAPP_FLASH_SIMULATOR

  #include "camflashsimulator.h"

#endif // CAMERAAPP_FLASH_SIMULATOR

#ifdef CAMERAAPP_CAE_ERR_SIMULATION

  #include "CamTimer.h"

#endif // CAMERAAPP_CAE_ERR_SIMULATION

#include "CamAppUi.h"

#include "CameraUiConfigManager.h"

#include "CamViewBase.h"   

#include "campanic.h"

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

// Local constants

const TInt KIveRecoveryCountMax = 2;  

typedef CCamera::CCameraAdvancedSettings CAS;

typedef CCamera::CCameraImageProcessing  CIP;

namespace NCamCameraController

  {

  static const TInt               KPrimaryCameraIndex         =  0;

  //static const TInt               KSecondaryCameraIndex       =  1;

  static const TInt               KInvalidCameraIndex         = -1;

  #ifdef CAMERAAPP_CAE_FOR_VIDEO

  //  static const TInt             KCameraDisplayIndex         = 0;

  #endif

  #ifdef CAMERAAPP_CAPI_V2

    static const TInt             KCameraClientPriority       = 100; // -100...100

  #endif

  static const TInt               KCamCallBackPriority        = EPriorityHigh;

  static const TInt               KCamSequenceGranularity     =  2;

  static const TInt               KResolutionArrayGranularity =  8;

  #ifdef CAMERAAPP_CAPI_V2_ADV

    static const TInt             KAdvArrayGranularity        =  5;

  #endif  

  static const CCamera::TFormat   KCamJpegAlternativeFormat1  = CCamera::EFormatFbsBitmapColor16M;

  static const CCamera::TFormat   KCamJpegAlternativeFormat2  = CCamera::EFormatFbsBitmapColor64K;

  static const TInt             KCamReserveTryAgainMaxCount     = 50;

  static const TInt             KCamReserveTryAgainWaitInterval = 50000; // 50 milliseconds

  #ifdef _DEBUG

  _LIT( KCamDriveModeNameBurst,   "EDriveModeBurst"      );

  _LIT( KCamDriveModeNameSingle,  "EDriveModeSingleShot" );

  _LIT( KCamDriveModeNameUnknown, "Unknown drive mode!"  );

  #endif // _DEBUG

  }

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

// Local methods

#ifdef CAMERAAPP_PERFORMANCE_CONTROLLER

  #include "camperformancelogger.h"

  #define CAMERAAPP_PERF_CONTROLLER_START( AAA )          iPerformanceLogger->Requested( AAA );

  #define CAMERAAPP_PERF_CONTROLLER_STARTNEW( AAA, BBB )  BBB = EFalse; iPerformanceLogger->Requested( AAA );

  #define CAMERAAPP_PERF_CONTROLLER_STOP( AAA )           iPerformanceLogger->Completed( AAA );

  #define CAMERAAPP_PERF_CONTROLLER_STOP_ONCE( AAA, BBB ) if( !BBB ) { iPerformanceLogger->Completed( AAA ); BBB = ETrue; }

#else

  #define CAMERAAPP_PERF_CONTROLLER_START( AAA )

  #define CAMERAAPP_PERF_CONTROLLER_STARTNEW( AAA, BBB )

  #define CAMERAAPP_PERF_CONTROLLER_STOP( AAA )

  #define CAMERAAPP_PERF_CONTROLLER_STOP_ONCE( AAA, BBB )

#endif // CAMERAAPP_PERFORMANCE_CONTROLLER

// Helper methods 

#include "camflagutility.inl"

#include "campointerutility.inl"

namespace NCamCameraController

  {

  /*

  inline void SetFalse( TAny* aTBool )

    {

    TBool* boolean = static_cast<TBool*>( aTBool );

    if( boolean )

      *boolean = EFalse;

    }

  */

  inline void SetNotBusy( TAny* aTUint )

    {

    TUint* flags = static_cast<TUint*>( aTUint );

    if( flags )

      *flags = ECamBusyOff;

    };

  inline void ReleaseAndNull( MCameraBuffer*& aBuffer )

    {

    if( aBuffer )

      {

      aBuffer->Release();

      aBuffer = NULL;

      }

    };

#ifdef CAMERAAPP_CAPI_V2_ADV

  inline void ResetInfo( TAny* aInfo )

    {

    TCamAdvancedSettingInfo* info = 

      static_cast<TCamAdvancedSettingInfo*>( aInfo );

    if( info )

      {

      info->Reset();

      }      

    };

  inline const TDesC& DriveModeName( TInt aMode )

    {

#ifdef _DEBUG

    switch( aMode )

      {

      case CAS::EDriveModeBurst:      return KCamDriveModeNameBurst;

      case CAS::EDriveModeSingleShot: return KCamDriveModeNameSingle;

      default:                        return KCamDriveModeNameUnknown;

      }

#else

    return KNullDesC;

#endif // _DEBUG

    };

#endif

  }

using namespace NCamCameraController;

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

// TCamControllerInfo class methods

TCamControllerInfo::TCamControllerInfo()

  {

  Reset();

  }

void

TCamControllerInfo::Reset( TBool aPreserveBusyFlag    /*= EFalse*/,

                           TBool aPreserveCameraIndex /*= EFalse*/ )

  {

  // When we reset the info e.g. after reserve lost event

  // we need to keep the current camera index stored.

  if( !aPreserveCameraIndex )

    {

    iCurrentCamera          = KErrNotFound;

    }

  iState                  = ECamIdle;

  iCaptureState           = ECamCaptureOff;

  iCaptureLimit           = 1;

  iCaptureCount           = 0;

  iSnapshotCount          = 0;

  iVfMode                 = ECamViewfinderNone;

  iVfState                = ECamTriIdle;

  iViewfinderSize         = TSize();

  iViewfinderFormat       = CCamera::EFormatFbsBitmapColor16M;

  iSsState                = ECamTriIdle;

  iSnapshotSize           = TSize();

  iSnapshotFormat         = CCamera::EFormatFbsBitmapColor16M;

  iSnapshotAspectMaintain = EFalse;

  if( !aPreserveBusyFlag )

    {

    iBusy = ECamBusyOff;  

    }

  }

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

// PrintInfo

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

//

void 

TCamControllerInfo::PrintInfo() const

  {

  PRINT ( _L("Camera <> --------------------------------------------------") );

  PRINT ( _L("Camera <> TCamControllerInfo")                                 );

  PRINT ( _L("Camera <> ")                                                   );

  PRINT1( _L("Camera <>   iCurrentCamera          :  %d"    ), iCurrentCamera );

  PRINT1( _L("Camera <>   iState                  :  %08b"  ), iState );

  PRINT1( _L("Camera <>   iCaptureState           : [%s]"   ), KCamCameraCaptureStateNames[iCaptureState] );

  PRINT1( _L("Camera <>   iCaptureLimit           :  %d"    ), iCaptureLimit );

  PRINT1( _L("Camera <>   iCaptureCount           :  %d"    ), iCaptureCount );

  PRINT1( _L("Camera <>   iSnapshotCount          :  %d"    ), iSnapshotCount );

  PRINT1( _L("Camera <>   iVfMode                 : [%s]"   ), KCamViewfinderModeNames    [iVfMode] );

  PRINT1( _L("Camera <>   iVfState                : [%s]"   ), KCamCameraTriStateNames    [iVfState] );

  PRINT2( _L("Camera <>   iViewfinderSize         : (%dx%d)"), iViewfinderSize.iWidth, iViewfinderSize.iHeight );

  PRINT1( _L("Camera <>   iViewfinderFormat       :  %d"    ), iViewfinderFormat );

  PRINT1( _L("Camera <>   iSsState                : [%s]"   ), KCamCameraTriStateNames    [iSsState] );

  PRINT2( _L("Camera <>   iSnapshotSize           : (%dx%d)"), iSnapshotSize.iWidth, iSnapshotSize.iHeight );

  PRINT1( _L("Camera <>   iSnapshotFormat         : %d"     ), iSnapshotFormat );

  PRINT1( _L("Camera <>   iSnapshotAspectMaintain : %d"     ), iSnapshotAspectMaintain );

  PRINT1( _L("Camera <>   iBusy                   : %08b"     ), iBusy );

  PRINT ( _L("Camera <> --------------------------------------------------") );

  }

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

// TCamCameraResolutionSupport class methods

TCamCameraResolutionSupport::TCamCameraResolutionSupport()

  : iResolutions( KResolutionArrayGranularity )

  {

  Reset();

  }

TCamCameraResolutionSupport::~TCamCameraResolutionSupport()

  {

  iResolutions.Close();

  }

void 

TCamCameraResolutionSupport::Reset()

  {

  iForCameraIndex  = KInvalidCameraIndex;

  iForCameraFormat = -1;

  iResolutions.Reset();

  }

#ifdef CAMERAAPP_CAPI_V2_ADV

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

// TCamAdvancedSettingInfo class methods

TCamAdvancedSettingInfo::TCamAdvancedSettingInfo()

  : iEvStepsSupport ( KAdvArrayGranularity ),

    iIsoRatesSupport( KAdvArrayGranularity )

  {

  Reset();

  }

TCamAdvancedSettingInfo::~TCamAdvancedSettingInfo()

  {

  iEvStepsSupport.Close();

  iIsoRatesSupport.Close();

  }

void 

TCamAdvancedSettingInfo::Reset()

  {

  iForCameraIndex = KInvalidCameraIndex;

  iEvModesSupport = 0;

  iEvStepsSupport.Reset();

  iEvStepsValueInfo = ENotActive;

  iIsoRatesSupport.Reset();

  iDigitalZoomSupport.Reset();

  iDigitalZoomValueInfo = ENotActive;

#ifdef CAMERAAPP_CAPI_V2_IP

  iColourEffectSupport.Reset();

  iColourEffectValueInfo = ENotActive;

  iSharpnessSupport.Reset();

  iSharpnessValueInfo = ENotActive;

#endif

  iStabilizationModeSupport       = 0;

  iStabilizationEffectSupport     = 0;

  iStabilizationComplexitySupport = 0;

  }

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

// PrintInfo

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

//

void 

TCamAdvancedSettingInfo::PrintInfo() const

  {

#ifdef _DEBUG

  PRINT ( _L("Camera <> --------------------------------------------------") );

  PRINT ( _L("Camera <> Value infos:")                                       );

  PRINT1( _L("Camera <> EV value info            : %04b"), iEvStepsValueInfo      );

  PRINT1( _L("Camera <> Dig zoom value info      : %04b"), iDigitalZoomValueInfo  );

#ifdef CAMERAAPP_CAPI_V2_IP

  PRINT1( _L("Camera <> Colour effct value info  : %04b"), iColourEffectValueInfo );

  PRINT1( _L("Camera <> Sharpness value info     : %04b"), iSharpnessValueInfo    );

#endif

  PRINT1( _L("Camera <> ENotActive               : %04b"), ENotActive               );

  PRINT1( _L("Camera <> EBitField                : %04b"), EBitField                );

  PRINT1( _L("Camera <> EDiscreteSteps           : %04b"), EDiscreteSteps           );

  PRINT1( _L("Camera <> EDiscreteRangeMinMaxStep : %04b"), EDiscreteRangeMinMaxStep );

  PRINT1( _L("Camera <> EContinuousRangeMinMax   : %04b"), EContinuousRangeMinMax   );

  PRINT ( _L("Camera <> --------------------------------------------------") );

  PRINT ( _L("Camera <> Dig zoom ratios:") );

  for( TInt i = 0; i < iDigitalZoomSupport.Count(); i++ )

    {

    PRINT2( _L("Camera <> step[%4d]: ratio[%4f]"), i, (TReal)iDigitalZoomSupport[i]/(TReal)KECamFineResolutionFactor );

    }

  PRINT ( _L("Camera <> --------------------------------------------------") );

  PRINT ( _L("Camera <> ISO rates supported:") );

  for( TInt i = 0; i < iIsoRatesSupport.Count(); i++ )

    {

    PRINT2( _L("Camera <> rate[%3d]: %4d"), i, iIsoRatesSupport[i] );

    }

  PRINT ( _L("Camera <> --------------------------------------------------") );

  PRINT ( _L("Camera <> EV steps supported:") );

  for( TInt i = 0; i < iEvStepsSupport.Count(); i++ )

    {

    PRINT2( _L("Camera <> step[%3d]: %4d"), i, iEvStepsSupport[i] );

    }

  PRINT ( _L("Camera <> --------------------------------------------------") );    

  PRINT1( _L("Camera <> Advanced EV modes support : %016b"), iEvModesSupport                    );

  PRINT1( _L("Camera <> EExposureAuto             : %016b"), CCamera::EExposureAuto             );

  PRINT1( _L("Camera <> EExposureNight            : %016b"), CCamera::EExposureNight            );

  PRINT1( _L("Camera <> EExposureBacklight        : %016b"), CCamera::EExposureBacklight        );

  PRINT1( _L("Camera <> EExposureCenter           : %016b"), CCamera::EExposureCenter           );

  PRINT1( _L("Camera <> EExposureSport            : %016b"), CCamera::EExposureSport            );

  PRINT1( _L("Camera <> EExposureVeryLong         : %016b"), CCamera::EExposureVeryLong         );

  PRINT1( _L("Camera <> EExposureSnow             : %016b"), CCamera::EExposureSnow             );

  PRINT1( _L("Camera <> EExposureBeach            : %016b"), CCamera::EExposureBeach            );

  PRINT1( _L("Camera <> EExposureProgram          : %016b"), CCamera::EExposureProgram          );

  PRINT1( _L("Camera <> EExposureAperturePriority : %016b"), CCamera::EExposureAperturePriority );

  PRINT1( _L("Camera <> EExposureShutterPriority  : %016b"), CCamera::EExposureShutterPriority  );

  PRINT1( _L("Camera <> EExposureManual           : %016b"), CCamera::EExposureManual           );

  PRINT1( _L("Camera <> EExposureSuperNight       : %016b"), CCamera::EExposureSuperNight       );

  PRINT1( _L("Camera <> EExposureInfra            : %016b"), CCamera::EExposureInfra            );

 PRINT ( _L("Camera <> --------------------------------------------------") );

#ifdef CAMERAAPP_CAPI_V2_IP

  PRINT ( _L("Camera <> Sharpness support:") );

  for( TInt i = 0; i < iSharpnessSupport.Count(); i++ )

    {

    PRINT2( _L("Camera <> step[%3d]: %4d"), i, iSharpnessSupport[i] );

    }

  PRINT ( _L("Camera <> --------------------------------------------------") );

  PRINT ( _L("Camera <> Colour effect support:") );

  for( TInt i = 0; i < iColourEffectSupport.Count(); i++ )

    {

    PRINT2( _L("Camera <> effect[%3d]           : %016b"), i, iColourEffectSupport[i] );

    }

  PRINT1( _L("Camera <> EEffectNone           : %016b"), CIP::EEffectNone            );

  PRINT1( _L("Camera <> EEffectNegative       : %016b"), CIP::EEffectNegative        );

  PRINT1( _L("Camera <> EEffectMonochrome     : %016b"), CIP::EEffectMonochrome      );

  PRINT1( _L("Camera <> EEffectSolarize       : %016b"), CIP::EEffectSolarize        );

  PRINT1( _L("Camera <> EEffectSepia          : %016b"), CIP::EEffectSepia           );

  PRINT1( _L("Camera <> EEffectEmboss         : %016b"), CIP::EEffectEmboss          );

  PRINT1( _L("Camera <> EEffectRedEyeReduction: %016b"), CIP::EEffectRedEyeReduction );

  PRINT1( _L("Camera <> EEffectVivid          : %016b"), CIP::EEffectVivid           );

  PRINT1( _L("Camera <> EEffectLowSharpening  : %016b"), CIP::EEffectLowSharpening   );

  PRINT ( _L("Camera <> --------------------------------------------------") );

#endif // CAMERAAPP_CAPI_V2_IP

  PRINT ( _L("Camera <> --------------------------------------------------") );    

  PRINT1( _L("Camera <> Stabilization modes support      : %016b"), iStabilizationModeSupport           );

  PRINT1( _L("Camera <>   EStabilizationModeOff          : %016b"), CAS::EStabilizationModeOff          );

  PRINT1( _L("Camera <>   EStabilizationModeHorizontal   : %016b"), CAS::EStabilizationModeHorizontal   );

  PRINT1( _L("Camera <>   EStabilizationModeVertical     : %016b"), CAS::EStabilizationModeVertical     );

  PRINT1( _L("Camera <>   EStabilizationModeRotation     : %016b"), CAS::EStabilizationModeRotation     );

  PRINT1( _L("Camera <>   EStabilizationModeAuto         : %016b"), CAS::EStabilizationModeAuto         );

  PRINT1( _L("Camera <>   EStabilizationModeManual       : %016b"), CAS::EStabilizationModeManual       );

  PRINT1( _L("Camera <> Stabilization fx support         : %016b"), iStabilizationEffectSupport         );

  PRINT1( _L("Camera <>   EStabilizationOff              : %016b"), CAS::EStabilizationOff              );

  PRINT1( _L("Camera <>   EStabilizationAuto             : %016b"), CAS::EStabilizationAuto             );

  PRINT1( _L("Camera <>   EStabilizationFine             : %016b"), CAS::EStabilizationFine             );

  PRINT1( _L("Camera <>   EStabilizationMedium           : %016b"), CAS::EStabilizationMedium           );

  PRINT1( _L("Camera <>   EStabilizationStrong           : %016b"), CAS::EStabilizationStrong           );

  PRINT1( _L("Camera <> Stabilization complexity support : %016b"), iStabilizationComplexitySupport     );

  PRINT1( _L("Camera <>   EStabilizationComplexityAuto   : %016b"), CAS::EStabilizationComplexityAuto   );

  PRINT1( _L("Camera <>   EStabilizationComplexityLow    : %016b"), CAS::EStabilizationComplexityLow    );

  PRINT1( _L("Camera <>   EStabilizationComplexityMedium : %016b"), CAS::EStabilizationComplexityMedium );

  PRINT1( _L("Camera <>   EStabilizationComplexityHigh   : %016b"), CAS::EStabilizationComplexityHigh   );

  PRINT ( _L("Camera <> --------------------------------------------------") );    

#endif // _DEBUG

  }

#endif // CAMERAAPP_CAPI_V2_ADV

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

// CCamCameraController class methods

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

// static 2-phase constructor

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

//

CCamCameraController*

CCamCameraController::NewL( MCamSettingProvider& aProvider, 

                            CCamAppController& aAppController, 

                            TInt aCameraIndex /*= 0*/ )  

  {

  CCamCameraController* self 

      = new (ELeave) CCamCameraController( aProvider, aAppController );  

  CleanupStack::PushL( self );

  self->ConstructL( aCameraIndex );

  CleanupStack::Pop( self );

  return self;

  }

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

//

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

//

CCamCameraController::~CCamCameraController()

  {

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

#ifdef CAMERAAPP_FLASH_SIMULATOR

  delete iFlashSimulator;

#endif 

#ifdef CAMERAAPP_PERFORMANCE_CONTROLLER

  delete iPerformanceLogger;

#endif // CAMERAAPP_PERFORMANCE_CONTROLLER

  delete iIdle; 

  iSettingArray.Close();

  // Remove all observers.

  // We do not want to broadcast events anymore in this phase.

  iObservers.Reset();

  iObserverInterests.Reset();

  ClearRequestQueue();

  ClearSettingQueue();

  PRINT( _L("Camera <> CCamCameraController: release current camera..") );  

  // Release and null CCamera related objects.

  ReleaseCurrentCamera();

  PRINT( _L("Camera <> CCamCameraController: ..done") );  

  delete iActive;

  iObservers.Close();