/*

* 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:  Class for managing intercommunication between Camera UI*

*/

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

// INCLUDE FILES

#include <bldvariant.hrh> // for feature definitions

#include <e32property.h>

#include <apparc.h>

#include <fbs.h>

#include <eikenv.h>

#include <hal.h>

#include <hal_data.h>

#include <pathinfo.h>

#include <barsread.h>

#include <AknUtils.h>

#include <akntoolbar.h>

#include <akntoolbarextension.h>

#include <centralrepository.h>

#include <ctsydomainpskeys.h>

#include <ProfileEngineSDKCRKeys.h>

#include <sysutildomaincrkeys.h>

#include <ScreensaverInternalPSKeys.h>

#include <musresourceproperties.h>

#include <cameraplatpskeys.h>

#include <bitmaptransforms.h>

#include <sensrvorientationsensor.h>

#include <sensrvchannel.h>

#include <sensrvchannelfinder.h>

#include <UsbWatcherInternalPSKeys.h>

#include <usbpersonalityids.h>

#include <UikonInternalPSKeys.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include "CamSettingsInternal.hrh"

#include "CamProductSpecificSettings.hrh"

#include "CameraappPrivateCRKeys.h"

#include "CamAppController.h"

#include "CamUtility.h"

#include "CamLogger.h"

#include "CamSettings.hrh"

#include "CamSettingsModel.h"

#include "CamPanic.h"

#include "CamBurstCaptureArray.h"

#include "CamTimer.h"

#include "CamImageSaveActive.h"

#include "CamAppUi.h"

#include "CamObserverHandler.h"

#include "CamSelfTimer.h"

#include "camflashstatus.h"

#include "CamPerformance.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamAppControllerTraces.h"

#endif

#include "CamVideoQualityLevel.h"

#include "CamCallStateAo.h"    

#include "CamPropertyWatcher.h"

#include <avkondomainpskeys.h>

#include <ProfileEngineInternalPSKeys.h>

#include <ProfileEnginePrivatePSKeys.h>

#ifndef __WINSCW__

  #include "rlocationtrail.h"

  #include "locationtrailpskeys.h"

#endif

//#include "camconstantsettingprovider.h"

#include "camsettingprovider.h"

#include "camsettingconversion.h"

#include "camcamerarequests.h"

#include "camcameraevents.h"

#include "camcameracontrollertypes.h"

#include "camcameracontroller.h"

#include "cambuffershare.h"

#include "cambuffersharecleanup.h"

#include "camaudioplayercontroller.h"

#include "camuidconstants.h"

#include "camconfiguration.h"

#include "CamPreCaptureViewBase.h"

#include "CamPostCaptureViewBase.h"

#include <cfclient.h>

#include <cfcontextobject.h>

#include <cfcontextquery.h>

#include "camvideotime.h"

#include "CamGSInterface.h"

#include "CameraUiConfigManager.h"

#include "camsnapshotrotator.h"

#include "CamVideoPreCaptureView.h"

#include <bitmaptransforms.h> 

#ifdef _DEBUG

#ifdef _AO_TRACKING

struct CFakeActiveScheduler : public CActiveScheduler {

  virtual TInt Extension_( TUint, TAny *&, TAny* ) { return 0; }

};

#endif // _AO_TRACKING

#endif // _DEBUG

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

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

const TInt KMinBurstCount    = 2;    // minimum of images captured

const TInt KBurstEstimate    = 10;   // Correction of underestimated file size  

const TUint32 KCamLatestFilePath      = 0x00000001;

// temporary constants until image naming is implemented

_LIT( KImageExtension, ".jpg" );

_LIT( KVideo3GPExtension, ".3gp" );

#ifndef __WINS__

_LIT( KVideoMP4Extension, ".mp4" );

#endif

const TInt KMaxExtension = 4;

//const TInt64 KBurstInterval = 0;

const TInt KIdleTimeout     = 1000000 * 60; // 60 seconds

const TInt KDeepSleepTimeout = KIdleTimeout*2; // Measuring time is two minutes  

const TInt KVideoArrayUsers = 1;

const TInt KImageArrayUsers = 2;

const TInt KVideoNameRetryCount = 1;    // Maximum number of video naming retries

// UID for central repository file

const TInt KCRCamShutterSound = 0x7; // key for shutter sound

const TInt KMicroSecsInMilliSec = 1000;

const TInt KSecondInMicSec = 1000000;

#if defined(RD_MDS_2_5) && !defined(__WINSCW__)

const TInt KLocTrailCloseRetryTime = 5 * KSecondInMicSec;

#endif // defined(RD_MDS_2_5) && !defined(__WINSCW__)

// Estimated time needed to complete autofocus

const TInt KFocusingDurationSeconds = 2;

const TInt KCCorFocused = 0x00000002;

const TInt KCamMaxDateLen = 8;

static const TInt KTimelapseArrayGranularity = 6;

// Backlight / Inactivity timer related

//   Callback interval is set to 4s. 

//   Smallest value that the user can select from Phone Settings is 5s.

static const TInt KBacklighTimerPriority = CActive::EPriorityHigh;

static const TInt KBacklighTimerInterval = 4*1000*1000; 

// Camera Controller events interest.

//   Want to receive all events.

//   Vf frames needed for correct zoom handling (should be left out otherwise).

static const TUint KCamEventInterest = (  ECamCameraEventClassAll );

static const TInt KLensCoverDelay = 500*1000;

_LIT( KCamContextSource, "Application" );

_LIT( KCamContextType, "Camera.Zoom" );

_LIT( KCamContextValueEnable, "Enabled" );

_LIT( KCamContextValueDisable, "Disabled" );

_LIT_SECURITY_POLICY_PASS( KCamContextSecurity );

static const TInt KCriticalMemoryLevel = 5*1000*1000;

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

// Local namespace

namespace NCamAppController

  {

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

  // Request sequences 

//  static const TCamCameraRequestId KCamSequencePowerOffOn[] = 

//    { 

//    ECamRequestPowerOff, 

//    ECamRequestPowerOn

//    };

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

  // Local methods

  inline TInt ResetBitmap( CFbsBitmap*& aBitmap )

    {

    if( aBitmap )

      {

      aBitmap->Reset();

      return KErrNone;

      }

    else

      {

      TRAPD( create, aBitmap = new (ELeave) CFbsBitmap() );

      return create;

      }

    };

  inline void ClearSequenceBusyFlag( TAny* aBusyFlags )

    {

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

    if( flags )

      {

      *flags &= ~EBusySequence;

      }

    };

  inline void ClearRequestBusyFlag( TAny* aBusyFlags )

    {

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

    if( flags )

      {

      *flags &= ~EBusyRequest;

      }

    };

  }

#include "camflagutility.inl"

#include "campointerutility.inl"

using namespace NCamAppController;

using namespace NCamCameraController;

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

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

// Member functions

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

// CCamAppController::NewL

// Two-phased constructor.

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

//

CCamAppController* CCamAppController::NewL()

    {

    CCamAppController* self = new( ELeave ) CCamAppController();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCamAppController::CompleteConstructionL

// The camera engine cannot be instantiated until the application orientation has 

// been set by the CCamAppUi. This does not exist when the CCamAppController is 

// constructed. CompleteConstructionL must be called in CCamAppUi::ConstructL()

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

//    

void CCamAppController::CompleteConstructionL()

  {

  PRINT( _L("Camera => CCamAppController::CompleteConstructionL" ))

  CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

  // Memory critical levels reading moved to the point when

  // those values are actually needed for the first time.   

  TInt index = 0;

  iInfo.iActiveCamera = ECamActiveCameraPrimary;

  PRINT1( _L("Camera <> Cameras available: %d"), CamerasAvailable() )

  PRINT( _L("Camera <> Store primary camera settings"))

  iSettingsModel->StorePrimaryCameraSettingsL();

  PRINT1( _L("Camera <> CCamAppController::CompleteConstructionL iSlideState initial value = %d" ), iSlideState)

  if ( iConfigManager->IsLensCoverSupported() )

      {

      // Request notification of slide state changes

      iSlideStateWatcher->Subscribe();

      // Read the current slider status - use the front camera (if there is one) as default if

      // there are any errors.

      TInt slideErr = iSlideStateWatcher->Get( iSlideState );

      PRINT1( _L("Camera <> CCamAppController::CompleteConstructionL setting iSlideState to %d" ), iSlideState)

      TInt requiredOrientation;

      if ( ( appUi->CamOrientation() == ECamOrientationCamcorderLeft && iSlideState == CameraPlatPSKeys::EClosed ) ||

            ( appUi->CamOrientation() == ECamOrientationCamcorder && iSlideState == CameraPlatPSKeys::EClosed ) )

        {

        if ( appUi->IsQwerty2ndCamera() )

            {  

            PRINT( _L("Camera <> Do not exit. Reload landscape 2nd camera settings") )

            index = 1;

            iInfo.iActiveCamera = ECamActiveCameraSecondary;

            CCamAppUi* appUi = static_cast<CCamAppUi*>( 

                               CEikonEnv::Static()->AppUi() ); 

            // We may have primary camera settings loaded 

            LoadStaticSettingsL( appUi->IsEmbedded() );   

            CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, 

                                   requiredOrientation );

            }

        else

            {

            PRINT( _L("Camera <> Lens cover has been closed during camera construction. Exit camera.") )

            appUi->HandleCommandL( EEikCmdExit);

            }

        }

      else  

        {  

        // if the slide is closed or there is an error, then use the front camera

        // check that there is more than 1 camera and that the current orientation is correct

        if ( ( iSlideState == CameraPlatPSKeys::EClosed               

              || slideErr    != KErrNone )

              && CamerasAvailable() > 1 )

          {

          PRINT( _L("Camera <> CCamAppController::CompleteConstructionL slider is not open" ))

          index = 1;

          iInfo.iActiveCamera = ECamActiveCameraSecondary;

          CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, requiredOrientation );

          }

        else // slide is open or using primary camera as default

          {

          PRINT( _L("Camera <> CCamAppController::CompleteConstructionL slider is open- primary camera in use" ))

          index = 0;

          iInfo.iActiveCamera = ECamActiveCameraPrimary;

          //when active camera is primary camera,orientation must be landscape,

          //so need to fix orientation

          if ( ECamOrientationPortrait == appUi->CamOrientation() )

            {

            TInt primaryOrientation;

            CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, 

                                      primaryOrientation );

            appUi->SetOrientationL( ( CAknAppUiBase::TAppUiOrientation ) primaryOrientation );		

            appUi->SetCamOrientationToLandscape();

            }

          }   

        }

      }

  ConstructCameraControllerL( index );

  // Send startup sequence ?

  /**

   * Removed all custom interfaces requested from engine

   */

  iAccSensorListening = EFalse;

  iCallStateAo = CCamCallStateAo::NewL( this );             

  // Use backlight timer instead of every Nth vf frame event

  // to reset inactivity timer. This is to avoid adding load

  // when higher VF frame rates are used (and overall load is

  // already higher).

  iBacklightTimer = CPeriodic::NewL( KBacklighTimerPriority );

#ifdef _DEBUG

#ifdef _AO_TRACKING

  TAny *iAoBacklightTimer = (TAny *)iBacklightTimer;

  PRINT2( _L("Camera <> CCamAppController: BacklightTimer=%x, %d"),iBacklightTimer, iAoBacklightTimer );

  CActiveScheduler *pAS = CActiveScheduler::Current();

  CFakeActiveScheduler *pFAS = static_cast<CFakeActiveScheduler*>(pAS);

  pFAS->Extension_( 0, iAoBacklightTimer, (TAny *)("iBacklightTimer") );

#endif // _AO_TRACKING

#endif // _DEBUG

#ifdef _DEBUG

#ifdef _AO_TRACKING

  TAny *iAoDeepSleepTimer = (TAny *)iDeepSleepTimer;

  PRINT2( _L("Camera <> CCamAppController: DeepSleepTimer=%x, %d"),iDeepSleepTimer, iAoDeepSleepTimer );

  CActiveScheduler *pAS2 = CActiveScheduler::Current();

  CFakeActiveScheduler *pFAS2 = static_cast<CFakeActiveScheduler*>(pAS2);

  pFAS2->Extension_( 0, iAoDeepSleepTimer, (TAny *)("iDeepSleepTimer") );

#endif // _AO_TRACKING

#endif // _DEBUG

  if ( UiConfigManagerPtr()->IsXenonFlashSupported() )

      {

      PRINT( _L("Camera <> CCamAppController: Create flash status observer..") );

      iFlashStatus = CCamFlashStatus::NewL( *this );

      }

  PRINT( _L("Camera <= CCamAppController::CompleteConstructionL" ))

  }    

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

// 

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

//

TInt 

CCamAppController::GetCriticalMemoryLevelL( const TCamMediaStorage& aStorage )

  {

  PRINT( _L("Camera => CCamAppController::GetCriticalMemoryLevelL" ) )

  // If this is the first call here, get the critical levels from

  // Central repository. Later the cached values will be used.

  if( KErrNotFound == iRamDiskCriticalLevel

   || KErrNotFound == iDiskCriticalLevel   )

    {

    CRepository* repository = CRepository::NewLC( KCRUidDiskLevel );

    TInt err;

    err = repository->Get( KDiskCriticalThreshold , iDiskCriticalLevel );

    if ( KErrNone != err )

      {

      CamPanic( ECamPanicDefaultNotFoundInIniFile );      

      }

    err = repository->Get( KRamDiskCriticalLevel , iRamDiskCriticalLevel ); 

    if ( KErrNone != err )

      {

      CamPanic( ECamPanicDefaultNotFoundInIniFile ); 

      } 

    CleanupStack::PopAndDestroy( repository );

    }

  TInt level = ( aStorage == ECamMediaStoragePhone ) 

             ? iRamDiskCriticalLevel

             : iDiskCriticalLevel;

  PRINT1( _L("Camera <= CCamAppController::GetCriticalMemoryLevelL, level:%d" ), level )

  return level;

  }

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

// CCamAppController::~CCamAppController

// Destructor

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

//

CCamAppController::~CCamAppController()

  { 

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

  // As a precaution, make sure the screen saver is never left in a disabled state

  EnableScreenSaver( ETrue );

  RProperty::Set( KPSUidCamcorderNotifier, KCCorFocused, 0 );

  if ( iFlashStatus )

    {

    delete iFlashStatus;

    }

  delete iSoundPlayer;

  PRINT( _L("Camera <> close observers array..") );

  __ASSERT_DEBUG( iControllerObservers.Count() == 0, CamPanic( ECamPanicResourceLeak ) );

  iControllerObservers.Close();

  delete iCallStateAo;    

  delete iBurstTimer;

// Using timer also on bitmap mode.

  if( iBacklightTimer )

    {

    iBacklightTimer->Cancel();

    delete iBacklightTimer;

    }

    if( iConfigManager && iConfigManager->IsOrientationSensorSupported() && 

    		iAccSensorListening )

        {

        iAccSensorChannel->StopDataListening();

        iAccSensorChannel->CloseChannel();

        }

    delete iAccSensorChannel;

  if ( iSlideStateWatcher )

    {

    iSlideStateWatcher->Cancel();

    delete iSlideStateWatcher;

    }

  if ( iSliderCallBack )

    { 

    iSliderCallBack->Cancel();

    delete iSliderCallBack;

    iSliderCallBack = NULL;

    }

  if ( iKeyLockStatusWatcher && iConfigManager && iConfigManager->IsKeyLockWatcherSupported() )

    {

    iKeyLockStatusWatcher->Cancel();

    delete iKeyLockStatusWatcher;

    }

  if ( iProfileStatusWatcher )

      {

      iProfileStatusWatcher->Cancel();

      delete iProfileStatusWatcher;

      }

  if ( iConfigManager  && iConfigManager->IsPublishZoomStateSupported() )

      {

      TRAP_IGNORE ( PublishZoomStateL( EFalse ) );

      delete iContextFwClient;      

      }

  if ( iConfigManager  && iConfigManager->IsLocationSupported() )

    {

    if( iLocationTrailTimer )

      {

      iLocationTrailTimer->Cancel();

      delete iLocationTrailTimer;

      iLocationTrailTimer = NULL;

      }

    }

  if ( iConfigManager  && iConfigManager->IsLocationSupported() )

    {

    // stop trail and close session