1 /*

     2 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Class for managing intercommunication between Camera UI*

    15 */

    16 

    17 

    18 

    19 // ===========================================================================

    20 // INCLUDE FILES

    21 

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

    23 

    24 #include <e32property.h>

    25 #include <apparc.h>

    26 #include <fbs.h>

    27 #include <eikenv.h>

    28 

    29 #include <hal.h>

    30 #include <hal_data.h>

    31 #include <pathinfo.h>

    32 #include <barsread.h>

    33 #include <AknUtils.h>

    34 #include <akntoolbar.h>

    35 #include <centralrepository.h>

    36 

    37 #include <ctsydomainpskeys.h>

    38 #include <ProfileEngineSDKCRKeys.h>

    39 #include <sysutildomaincrkeys.h>

    40 #include <ScreensaverInternalPSKeys.h>

    41 #include <musresourceproperties.h>

    42 #include <cameraplatpskeys.h>

    43 #include <bitmaptransforms.h>

    44 #include <sensrvorientationsensor.h>

    45 #include <sensrvchannel.h>

    46 #include <sensrvchannelfinder.h>

    47 

    48 #include <UsbWatcherInternalPSKeys.h>

    49 #include <usbpersonalityids.h>

    50 

    51 

    52 #include <cameraapp.rsg>

    53 #include <vgacamsettings.rsg>

    54 #include "CamSettingsInternal.hrh"

    55 #include "CamProductSpecificSettings.hrh"

    56 #include "CameraappPrivateCRKeys.h"

    57 #include "CamAppController.h"

    58 #include "CamUtility.h"

    59 #include "CamLogger.h"

    60 #include "CamSettings.hrh"

    61 #include "CamSettingsModel.h"

    62 #include "CamPanic.h"

    63 #include "CamBurstCaptureArray.h"

    64 #include "CamTimer.h"

    65 #include "CamImageSaveActive.h"

    66 #include "CamAppUi.h"

    67 #include "CamObserverHandler.h"

    68 #include "CamSelfTimer.h"

    69 #include "camflashstatus.h"

    70 

    71 #include "CamPerformance.h"

    72 #include "OstTraceDefinitions.h"

    73 #ifdef OST_TRACE_COMPILER_IN_USE

    74 #include "CamAppControllerTraces.h"

    75 #endif

    76 

    77 #include "CamVideoQualityLevel.h"

    78 #include "CamCallStateAo.h"    

    79 #include "CamPropertyWatcher.h"

    80 #include <avkondomainpskeys.h>

    81 

    82 #ifndef __WINSCW__

    83   #include "rlocationtrail.h"

    84   #include "locationtrailpskeys.h"

    85 #endif

    86 //#include "camconstantsettingprovider.h"

    87 #include "camsettingprovider.h"

    88 #include "camsettingconversion.h"

    89 #include "camcamerarequests.h"

    90 #include "camcameraevents.h"

    91 #include "camcameracontrollertypes.h"

    92 #include "camcameracontroller.h"

    93 #include "cambuffershare.h"

    94 #include "cambuffersharecleanup.h"

    95 #include "camaudioplayercontroller.h"

    96 #include "camuidconstants.h"

    97 #include "camconfiguration.h"

    98 #include "CamPreCaptureViewBase.h"

    99 

   100 #include <cfclient.h>

   101 #include <cfcontextobject.h>

   102 #include <cfcontextquery.h>

   103 

   104 #include "camvideotime.h"

   105 #include "CamGSInterface.h"

   106 #include "CameraUiConfigManager.h"

   107 #include "camsnapshotrotator.h"

   108 #include <bitmaptransforms.h> 

   109 

   110 #ifdef _DEBUG

   111 #ifdef _AO_TRACKING

   112 struct CFakeActiveScheduler : public CActiveScheduler {

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

   114 };

   115 #endif // _AO_TRACKING

   116 #endif // _DEBUG

   117 

   118 // ===========================================================================

   119 // Local constants

   120 

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

   122 // with sequence mode.

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

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

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

   126 

   127 const TUint32 KCamLatestFilePath      = 0x00000001;

   128 

   129 

   130 // temporary constants until image naming is implemented

   131 _LIT( KImageExtension, ".jpg" );

   132 _LIT( KVideo3GPExtension, ".3gp" );

   133 #ifndef __WINS__

   134 _LIT( KVideoMP4Extension, ".mp4" );

   135 #endif

   136 

   137 const TInt KMaxExtension = 4;

   138 //const TInt64 KBurstInterval = 0;

   139 

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

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

   142 const TInt KVideoArrayUsers = 1;

   143 const TInt KImageArrayUsers = 2;

   144 

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

   146 

   147 // UID for central repository file

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

   149 

   150 const TInt KMicroSecsInMilliSec = 1000;

   151 const TInt KSecondInMicSec = 1000000;

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

   153 const TInt KLocTrailCloseRetryTime = 5 * KSecondInMicSec;

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

   155 

   156 // Estimated time needed to complete autofocus

   157 const TInt KFocusingDurationSeconds = 2;

   158 

   159 const TInt KCCorFocused = 0x00000002;

   160 

   161 const TInt KCamMaxDateLen = 8;

   162 

   163 static const TInt KTimelapseArrayGranularity = 6;

   164 

   165 // Backlight / Inactivity timer related

   166 //   Callback interval is set to 4s. 

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

   168 static const TInt KBacklighTimerPriority = CActive::EPriorityHigh;

   169 static const TInt KBacklighTimerInterval = 4*1000*1000; 

   170 

   171 // Camera Controller events interest.

   172 //   Want to receive all events.

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

   174 static const TUint KCamEventInterest = (  ECamCameraEventClassAll );

   175 

   176 static const TInt KLensCoverDelay = 500*1000;

   177 

   178 _LIT( KCamContextSource, "Application" );

   179 _LIT( KCamContextType, "Camera.Zoom" );

   180 _LIT( KCamContextValueEnable, "Enabled" );

   181 _LIT( KCamContextValueDisable, "Disabled" );

   182 _LIT_SECURITY_POLICY_PASS( KCamContextSecurity );

   183 

   184 static const TInt KCriticalMemoryLevel = 5*1000*1000;

   185 // ===========================================================================

   186 // Local namespace

   187 namespace NCamAppController

   188   {

   189   // -------------------------------------------------------

   190   // Request sequences 

   191 //  static const TCamCameraRequestId KCamSequencePowerOffOn[] = 

   192 //    { 

   193 //    ECamRequestPowerOff, 

   194 //    ECamRequestPowerOn

   195 //    };

   196   

   197   // -------------------------------------------------------

   198   // Local methods

   199 

   200   inline TInt ResetBitmap( CFbsBitmap*& aBitmap )

   201     {

   202     if( aBitmap )

   203       {

   204       aBitmap->Reset();

   205       return KErrNone;

   206       }

   207     else

   208       {

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

   210       return create;

   211       }

   212     };

   213 

   214   inline void ClearSequenceBusyFlag( TAny* aBusyFlags )

   215     {

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

   217     if( flags )

   218       {

   219       *flags &= ~EBusySequence;

   220       }

   221     };

   222 

   223   inline void ClearRequestBusyFlag( TAny* aBusyFlags )

   224     {

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

   226     if( flags )

   227       {

   228       *flags &= ~EBusyRequest;

   229       }

   230     };

   231   }

   232 

   233 #include "camflagutility.inl"

   234 #include "campointerutility.inl"

   235 

   236 using namespace NCamAppController;

   237 using namespace NCamCameraController;

   238 // ===========================================================================

   239 

   240 

   241 // ===========================================================================

   242 // Member functions

   243 

   244 // ---------------------------------------------------------------------------

   245 // CCamAppController::NewL

   246 // Two-phased constructor.

   247 // ---------------------------------------------------------------------------

   248 //

   249 CCamAppController* CCamAppController::NewL()

   250     {

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

   252     CleanupStack::PushL( self );

   253     self->ConstructL();

   254     CleanupStack::Pop( self );

   255     return self;

   256     }

   257 

   258 

   259 // ---------------------------------------------------------------------------

   260 // CCamAppController::CompleteConstructionL

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

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

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

   264 // ---------------------------------------------------------------------------

   265 //    

   266 void CCamAppController::CompleteConstructionL()

   267   {

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

   269 

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

   271   

   272   // Memory critical levels reading moved to the point when

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

   274 

   275   TInt index = 0;

   276   iInfo.iActiveCamera = ECamActiveCameraPrimary;

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

   278   

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

   280   iSettingsModel->StorePrimaryCameraSettingsL();

   281 

   282 

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

   284   if ( iConfigManager->IsLensCoverSupported() )

   285       {

   286       // Request notification of slide state changes

   287       iSlideStateWatcher->Subscribe();

   288 

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

   290       // there are any errors.

   291       TInt slideErr = iSlideStateWatcher->Get( iSlideState );

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

   293       TInt requiredOrientation;

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

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

   296         {

   297         if ( appUi->IsQwerty2ndCamera() )

   298             {  

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

   300             index = 1;

   301             iInfo.iActiveCamera = ECamActiveCameraSecondary;

   302             CCamAppUi* appUi = static_cast<CCamAppUi*>( 

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

   304             // We may have primary camera settings loaded 

   305             LoadStaticSettingsL( appUi->IsEmbedded() );   

   306             CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, 

   307                                    requiredOrientation );

   308             }

   309         else

   310             {

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

   312             appUi->HandleCommandL( EEikCmdExit);

   313             }

   314         }

   315       else  

   316         {  

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

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

   319         if ( ( iSlideState == CameraPlatPSKeys::EClosed               

   320               || slideErr    != KErrNone )

   321               && CamerasAvailable() > 1 )

   322           {

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

   324           index = 1;

   325           iInfo.iActiveCamera = ECamActiveCameraSecondary;

   326           CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, requiredOrientation );

   327           }

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

   329           {

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

   331           index = 0;

   332           iInfo.iActiveCamera = ECamActiveCameraPrimary;

   333 

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

   335           //so need to fix orientation

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

   337             {

   338             TInt primaryOrientation;

   339             CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, 

   340                                       primaryOrientation );

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

   342             appUi->SetCamOrientationToLandscape();

   343             }

   344           }   

   345         }

   346       }

   347 

   348   ConstructCameraControllerL( index );

   349   

   350   // Send startup sequence ?

   351 

   352   /**

   353    * Removed all custom interfaces requested from engine

   354    */

   355   iAccSensorListening = EFalse;

   356 

   357   iCallStateAo = CCamCallStateAo::NewL( this );             

   358   

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

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

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

   362   // already higher).

   363   iBacklightTimer = CPeriodic::NewL( KBacklighTimerPriority );

   364 

   365 #ifdef _DEBUG

   366 #ifdef _AO_TRACKING

   367   TAny *iAoBacklightTimer = (TAny *)iBacklightTimer;

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

   369   CActiveScheduler *pAS = CActiveScheduler::Current();

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

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

   372 #endif // _AO_TRACKING

   373 #endif // _DEBUG

   374 

   375 #ifdef _DEBUG

   376 #ifdef _AO_TRACKING

   377   TAny *iAoDeepSleepTimer = (TAny *)iDeepSleepTimer;

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

   379   CActiveScheduler *pAS2 = CActiveScheduler::Current();

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

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

   382 #endif // _AO_TRACKING

   383 #endif // _DEBUG

   384 

   385 

   386   if ( UiConfigManagerPtr()->IsXenonFlashSupported() )

   387       {

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

   389       iFlashStatus = CCamFlashStatus::NewL( *this );

   390       }

   391 

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

   393   }    

   394 

   395 

   396 // ---------------------------------------------------------------------------

   397 // 

   398 // ---------------------------------------------------------------------------

   399 //

   400 TInt 

   401 CCamAppController::GetCriticalMemoryLevelL( const TCamMediaStorage& aStorage )

   402   {

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

   404 

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

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

   407   if( KErrNotFound == iRamDiskCriticalLevel

   408    || KErrNotFound == iDiskCriticalLevel   )

   409     {

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

   411     TInt err;

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

   413     if ( KErrNone != err )

   414       {

   415       CamPanic( ECamPanicDefaultNotFoundInIniFile );      

   416       }

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

   418     if ( KErrNone != err )

   419       {

   420       CamPanic( ECamPanicDefaultNotFoundInIniFile ); 

   421       } 

   422     CleanupStack::PopAndDestroy( repository );

   423     }

   424   

   425   TInt level = ( aStorage == ECamMediaStoragePhone ) 

   426              ? iRamDiskCriticalLevel

   427              : iDiskCriticalLevel;

   428 

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

   430   return level;

   431   }

   432 

   433 // ---------------------------------------------------------------------------

   434 // CCamAppController::~CCamAppController

   435 // Destructor

   436 // ---------------------------------------------------------------------------

   437 //

   438 CCamAppController::~CCamAppController()

   439   { 

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

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

   442   EnableScreenSaver( ETrue );

   443 

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

   445   

   446   if ( iFlashStatus )

   447     {

   448     delete iFlashStatus;

   449     }

   450 

   451   delete iSoundPlayer;

   452 

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

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

   455   iControllerObservers.Close();

   456 

   457   delete iCallStateAo;    

   458 

   459   delete iBurstTimer;

   460 

   461 // Using timer also on bitmap mode.

   462   if( iBacklightTimer )

   463     {

   464     iBacklightTimer->Cancel();

   465     delete iBacklightTimer;

   466     }

   467 

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

   469     		iAccSensorListening )

   470         {

   471         iAccSensorChannel->StopDataListening();

   472         iAccSensorChannel->CloseChannel();

   473         }

   474     delete iAccSensorChannel;

   475 

   476   if ( iSlideStateWatcher )

   477     {

   478     iSlideStateWatcher->Cancel();

   479     delete iSlideStateWatcher;

   480     }

   481   

   482   if ( iSliderCallBack )

   483     { 

   484     iSliderCallBack->Cancel();

   485     delete iSliderCallBack;

   486     iSliderCallBack = NULL;

   487     }

   488 

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

   490     {

   491     iKeyLockStatusWatcher->Cancel();

   492     delete iKeyLockStatusWatcher;

   493     }

   494   

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

   496       {

   497       TRAP_IGNORE ( PublishZoomStateL( EFalse ) );

   498       delete iContextFwClient;      

   499       }

   500 

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

   502     {

   503     if( iLocationTrailTimer )

   504       {

   505       iLocationTrailTimer->Cancel();

   506       delete iLocationTrailTimer;

   507       iLocationTrailTimer = NULL;

   508       }

   509     }

   510       

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

   512     {

   513     // stop trail and close session

   514     StopLocationTrail( ETrue );

   515     }

   516 

   517   if ( iImageSaveActive )  

   518     {

   519       iImageSaveActive->ForceCancel();

   520     delete iImageSaveActive;

   521     }

   522 

   523   PRINT( _L("Camera <> delete settingsmodel..") );

   524   delete iSettingsModel;  // Must be before iEngine deleted

   525   iSettingsPreviewHandler = NULL; // Currently the Settings Model object.

   526   iPreviewRollbacks.Close();

   527 

   528 

   529   delete iCaptureArray;

   530   delete iRotationArray;

   531   if ( iSequenceFilenameArray )

   532     {

   533     iSequenceFilenameArray->Reset();

   534     delete iSequenceFilenameArray;

   535     }    

   536 

   537   if( iDeepSleepTimer )

   538     {

   539     iDeepSleepTimer->Cancel();

   540     delete iDeepSleepTimer;

   541     }

   542 

   543   if( iIdleTimer )

   544     {

   545     iIdleTimer->Cancel();

   546     delete iIdleTimer;

   547     }

   548 

   549   if ( iTimeLapseTimer )

   550     {

   551     iTimeLapseTimer->Cancel();

   552     delete iTimeLapseTimer;

   553     }

   554 

   555   if( iCaptureToneDelayTimer )

   556     {

   557     iCaptureToneDelayTimer->Cancel();

   558     delete iCaptureToneDelayTimer;

   559     }

   560 

   561   delete iCaptureCompletionObserverHandler;      

   562   delete iSnapShotCopy; 

   563     

   564   iJpegDataSizes.Close();

   565   iSequencePostProcessDataSizes.Close();

   566   

   567   // Close the arrays

   568   iPendingObserversArray.Close();

   569   iCameraEventInterested.Close();

   570 

   571   // Controller handles releasing CCamera if needed.

   572   PRINT( _L("Camera <> delete camera controller..") );

   573   delete iCameraController;

   574   PRINT( _L("Camera <> delete setting provider..") );

   575   delete iSettingProvider;

   576   PRINT( _L("Camera <= ~CCamAppController") );

   577   

   578   PRINT( _L("Camera <> delete Configuration Manager..") );

   579   delete iConfiguration;

   580   iConfiguration = NULL;  

   581 

   582   RProperty::Delete( KPSUidCamcorderNotifier, KCCorFocused );  

   583     if( iPlugin )

   584         {

   585         // Destroy Ecom plugin

   586         iPlugin->DestroyPlugin();

   587         }

   588   iPlugin = NULL;

   589   delete iDriveChangeNotifier;

   590   iFs.Close();

   591   

   592   if( iRotatorAo )

   593       {

   594       delete iRotatorAo;

   595       }

   596 

   597   delete iSnapShotRotator;

   598   PRINT( _L("Camera <= ~CCamAppController") );

   599   }

   600 

   601 

   602 // ---------------------------------------------------------------------------

   603 // CCamAppController::SavedCurrentImage

   604 // Returns whether the last requested captured image has been saved or not.

   605 // ---------------------------------------------------------------------------

   606 //

   607 TBool CCamAppController::SavedCurrentImage() const

   608   {

   609   PRINT( _L("Camera => CCamAppController::SavedCurrentImage") );

   610   TBool saved( ETrue );

   611 

   612   // If we are waiting for a save request then image has not been saved.

   613   if( iImageSaveRequestPending )

   614     {

   615     PRINT( _L("Camera <> CCamAppController::SavedCurrentImage: iImageSaveRequestPending") )

   616     saved = EFalse;

   617     }

   618   else if( CurrentFullFileName() == KNullDesC )

   619     {

   620     saved = EFalse;

   621     PRINT( _L("Camera <> CCamAppController::SavedCurrentImage: filename not yet reserved") ) 

   622     }

   623   else if( !iCaptureArray->AlreadySavedFile( CurrentFullFileName() ) ||

   624             iCaptureArray->CurrentlySavingFile( CurrentFullFileName() ) )

   625     {

   626     PRINT( _L("Camera <> CCamAppController::SavedCurrentImage: capture array not saved file or currently saving file") )

   627     saved = EFalse;

   628     }

   629   else if ( iInfo.iOperation == ECamCapturing || iInfo.iOperation == ECamCompleting )

   630     {

   631    	PRINT(_L("Camera CCamAppController::SavedCurrentImage returning false, capturing/completing") )

   632    	saved = EFalse;    

   633     }

   634   else

   635     {

   636     // empty

   637     }

   638 

   639   PRINT1( _L("Camera <= CCamAppController::SavedCurrentImage, return %d"), saved );

   640   return saved;

   641   }

   642 

   643 // ---------------------------------------------------------------------------

   644 // CCamAppController::RenameCurrentFileL

   645 // Rename image/video.

   646 // ---------------------------------------------------------------------------

   647 //

   648 TBool 

   649 CCamAppController::RenameCurrentFileL( const TDesC&          aNewName, 

   650                                        const TCamCameraMode& /*aMode*/ )

   651   {

   652   TBool status = EFalse;

   653 

   654   // If file to rename has already been saved then remove from album,

   655   // rename the file and add the renamed file to the album.

   656   if ( BurstCaptureArray()->AlreadySavedFile( CurrentFullFileName() ) )

   657     {                

   658     // Rename the file.

   659     TFileName filePath = CurrentFullFileName();

   660     CamUtility::RenameStillImageL( filePath, aNewName, filePath );

   661     

   662     // Update capture array with new name and path.

   663     BurstCaptureArray()->SetNameL( filePath, aNewName, iCurrentImageIndex );

   664     

   665     status = ETrue;

   666     }

   667   // Otherwise, if the file is not currently being saved, modify the names 

   668   // in the capture array before it is saved.

   669   else if ( !BurstCaptureArray()->CurrentlySavingFile( CurrentFullFileName() ) )

   670     {

   671     // Update capture array with new name and path.

   672     // ...determine new path.

   673     TParsePtrC parse( CurrentFullFileName() );

   674     TFileName fullNewPath;

   675     fullNewPath = parse.DriveAndPath();

   676     fullNewPath.Append( aNewName );

   677     fullNewPath.Append( parse.Ext() );

   678 

   679     BurstCaptureArray()->SetNameL( fullNewPath, aNewName, iCurrentImageIndex );

   680 

   681     status = ETrue;

   682     }

   683   // Otherwise, the file is in the process of being saved, and 

   684   // so that renaming must wait until completed.

   685   else

   686     {

   687     // Leave status to EFalse

   688     }

   689     

   690   return status;

   691   }

   692 

   693 

   694 // ---------------------------------------------------------------------------

   695 // CCamAppController::AddControllerObserverL

   696 // Add a controller observer.

   697 // ---------------------------------------------------------------------------

   698 //

   699 void CCamAppController::AddControllerObserverL( const MCamControllerObserver* aObserver )

   700   {

   701   if( aObserver &&

   702       KErrNotFound == iControllerObservers.Find( aObserver ) )

   703     {

   704     User::LeaveIfError( iControllerObservers.Append( aObserver ) );

   705     }

   706   }

   707 

   708 // ---------------------------------------------------------------------------

   709 // CCamAppController::RemoveControllerObserver

   710 // Remove a controller observer.

   711 // ---------------------------------------------------------------------------

   712 //

   713 void CCamAppController::RemoveControllerObserver( const MCamControllerObserver* aObserver )

   714   {

   715   // Errors ignored

   716   if( aObserver )

   717     {

   718     TInt index = iControllerObservers.Find( aObserver );

   719     if( KErrNotFound != index )

   720       {

   721       iControllerObservers.Remove( index );

   722       }

   723     }

   724   }

   725 

   726 // ---------------------------------------------------------------------------

   727 // AddCameraObserverL

   728 // ---------------------------------------------------------------------------

   729 //

   730 void 

   731 CCamAppController

   732 ::AddCameraObserverL( const MCamCameraObserver* aObserver, 

   733                       const TUint&              aEventInterest )

   734   {

   735   PRINT1( _L("Camera => CCamAppController::AddCameraObserverL aObserver=%d"), aObserver );

   736 

   737   // First check that observer is not in array already

   738   if( KErrNotFound == iPendingObserversArray.Find( aObserver ) )

   739       {  

   740       PRINT(_L("Camera <> CCamAppController::AddCameraObserverL add Observer") );

   741 

   742       iPendingObserversArray.AppendL( aObserver );

   743       iCameraEventInterested.AppendL( aEventInterest );

   744       }

   745 

   746   if( iCameraController )

   747       {

   748       PRINT(_L("Camera <> CCamAppController::AddCameraObserverL camera controller available") );

   749       while ( iPendingObserversArray.Count() > 0 &&

   750               iCameraEventInterested.Count() > 0 )

   751           {

   752           const MCamCameraObserver* camEventObserver = iPendingObserversArray[0];

   753           TUint eventInterest = iCameraEventInterested[0];

   754           iCameraController->AttachObserverL( camEventObserver, eventInterest );

   755           iPendingObserversArray.Remove( 0 );

   756           iCameraEventInterested.Remove( 0 );

   757           } 

   758       }

   759   PRINT(_L("Camera <= CCamAppController::AddCameraObserverL") );

   760   }

   761 

   762 // ---------------------------------------------------------------------------

   763 // RemoveCameraObserver

   764 // ---------------------------------------------------------------------------

   765 //

   766 void 

   767 CCamAppController

   768 ::RemoveCameraObserver( const MCamCameraObserver* aObserver )

   769   {

   770   if( iCameraController )

   771     iCameraController->DetachObserver( aObserver );

   772   }

   773 

   774 // ---------------------------------------------------------------------------

   775 // AddSettingsObserverL

   776 // ---------------------------------------------------------------------------

   777 //

   778 void

   779 CCamAppController

   780 ::AddSettingsObserverL( const MCamSettingsModelObserver* aObserver )

   781   {

   782   if( iSettingsModel )

   783     iSettingsModel->AttachObserverL( aObserver );

   784   else

   785     User::Leave( KErrNotReady );

   786   }

   787 

   788 // ---------------------------------------------------------------------------

   789 // RemoveCameraObserver

   790 // ---------------------------------------------------------------------------

   791 //

   792 void 

   793 CCamAppController

   794 ::RemoveSettingsObserver( const MCamSettingsModelObserver* aObserver )

   795   {

   796   if( iSettingsModel )

   797     iSettingsModel->DetachObserver( aObserver );

   798   }

   799 

   800 

   801 // ---------------------------------------------------------------------------

   802 //

   803 // ---------------------------------------------------------------------------

   804 //

   805 void 

   806 CCamAppController::ConstructCameraControllerL( TInt aCameraIndex )

   807   {

   808   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMAPPCONTROLLER_CONSTRUCTCAMERACONTROLLERL, "e_CCamAppController_ConstructCameraControllerL 1" );

   809   PRINT( _L("Camera => CCamAppController::ConstructCameraControllerL") )

   810   PERF_EVENT_START_L2( EPerfEventCAEConstruction );

   811 

   812   if( !iCameraController )

   813     {

   814     iCameraController = CCamCameraController::NewL( *iSettingProvider, *this,

   815                                                     aCameraIndex ); 

   816     //If uiorientationoverride feature is not supported, the camera switch has

   817     // to be finished here                                                    

   818     if( !( iConfigManager && iConfigManager->IsUIOrientationOverrideSupported() ) )

   819       {

   820       iCameraController->CompleteSwitchCameraL();

   821       }

   822     }

   823 

   824   // Attach as Camera Controller observer to get events

   825   PRINT1( _L("Camera <> Attaching as camera observer with interest:%032b"), KCamEventInterest );

   826   iCameraController->AttachObserverL( this, KCamEventInterest );

   827 

   828 

   829   PERF_EVENT_END_L2( EPerfEventCAEConstruction );

   830   PRINT( _L("Camera <= CCamAppController::ConstructCameraControllerL") )

   831   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMAPPCONTROLLER_CONSTRUCTCAMERACONTROLLERL, "e_CCamAppController_ConstructCameraControllerL 0" );

   832   }

   833 

   834 // #################################################################################################

   835 

   836 // ---------------------------------------------------------------------------

   837 // Returns the current camera controller state

   838 // (Bitfield of type TCamCameraStateFlags )

   839 // ---------------------------------------------------------------------------

   840 //

   841 TUint

   842 CCamAppController::CameraControllerState() const

   843   {

   844   TUint state( ECamIdle );

   845   if( iCameraController )

   846     {

   847     state = iCameraController->State();

   848     }

   849   PRINT1( _L("Camera =><= CCamAppController::CameraControllerState(): %032b"), state );

   850   return state;

   851   }

   852   

   853 // ---------------------------------------------------------------------------

   854 // Returns the current camera state

   855 // (TCamCameraState)

   856 // ---------------------------------------------------------------------------

   857 //

   858 TCamCameraState

   859 CCamAppController::CameraState() const

   860   {

   861   TCamCameraState state( ECamCameraIdle );  

   862   

   863   TUint controllerState = CameraControllerState();

   864  

   865   // Convert controller state to TCamCameraState

   866   // Use the state represented by the "most significant"

   867   // bit in the bitfield. Ignore VF state.

   868   if( IsFlagOn( controllerState, ECamImageOn ) )

   869     {

   870     state = ECamCameraPreparedImage;

   871     }

   872   else if( IsFlagOn( controllerState, ECamVideoOn ) )

   873     {

   874     state = ECamCameraPreparedVideo;  

   875     }

   876   else if( IsFlagOn( controllerState, ECamPowerOn ) )  

   877     {

   878     state = ECamCameraPowerOn;  

   879     }

   880   else if( IsFlagOn( controllerState, ECamReserved ) )  

   881     {

   882     state = ECamCameraReserved;  

   883     }

   884     

   885   PRINT1( _L("Camera =><= CCamAppController::CameraState(): %d"), state );

   886   return state;

   887   }  

   888 

   889 // ---------------------------------------------------------------------------

   890 //

   891 // ---------------------------------------------------------------------------

   892 //

   893 TCamCameraMode

   894 CCamAppController::CurrentMode() const

   895   {

   896   return iInfo.iMode;

   897   }

   898 

   899 // ---------------------------------------------------------------------------

   900 //

   901 // ---------------------------------------------------------------------------

   902 //

   903 TCamCameraMode

   904 CCamAppController::TargetMode() const

   905   {

   906   return iInfo.iTargetMode;

   907   }

   908 

   909 // ---------------------------------------------------------------------------

   910 //

   911 // ---------------------------------------------------------------------------

   912 //

   913 // CCamAppController::CurrentCaptureModeSetup()

   914 TCamImageCaptureMode

   915 CCamAppController::CurrentImageModeSetup() const

   916   {

   917   TCamImageCaptureMode captureMode = ECamImageCaptureSingle; 

   918   if( IsAppUiAvailable() ) 

   919     { 

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

   921     if ( appUi->IsBurstEnabled() ) 

   922       { 

   923       captureMode = appUi->CurrentBurstMode(); 

   924       } 

   925     } 

   926   return captureMode; 

   927   }

   928 

   929 // ---------------------------------------------------------------------------

   930 //

   931 // ---------------------------------------------------------------------------

   932 //

   933 TCamCaptureOperation

   934 CCamAppController::CurrentOperation() const

   935   {

   936   return iInfo.iOperation;

   937   }

   938 

   939 // ---------------------------------------------------------------------------

   940 //

   941 // ---------------------------------------------------------------------------

   942 //

   943 TCamCaptureOperation

   944 CCamAppController::CurrentImageOperation() const

   945   {

   946   if( ECamControllerImage == iInfo.iMode )

   947     return iInfo.iOperation;

   948   else

   949     return ECamNoOperation;

   950   }

   951 

   952 // ---------------------------------------------------------------------------

   953 //

   954 // ---------------------------------------------------------------------------

   955 //

   956 TCamCaptureOperation  

   957 CCamAppController::CurrentVideoOperation() const

   958   {

   959   if( ECamControllerVideo == iInfo.iMode )

   960     return iInfo.iOperation;

   961   else

   962     return ECamNoOperation;

   963   }

   964 

   965 // ---------------------------------------------------------------------------

   966 //

   967 // ---------------------------------------------------------------------------

   968 //

   969 TCamImageCaptureMode  CCamAppController::CurrentImageMode() const

   970     {

   971     return iInfo.iImageMode;

   972     }

   973 // ---------------------------------------------------------------------------

   974 //

   975 // ---------------------------------------------------------------------------

   976 //

   977 TCamCameraTriState CCamAppController::ViewfinderTargetState() const

   978   {

   979   return iInfo.iTargetVfState;

   980   }

   981 

   982 

   983 // ---------------------------------------------------------------------------

   984 //

   985 // ---------------------------------------------------------------------------

   986 //

   987 void 

   988 CCamAppController::SetMode( const TCamCameraMode& aNewMode )

   989   {

   990   PRINT3( _L("Camera => CCamAppController::SetMode old[%s] new[%s] target[%s]"), 

   991           KCamModeNames[iInfo.iMode], 

   992           KCamModeNames[aNewMode],

   993           KCamModeNames[iInfo.iTargetMode] );

   994 

   995   if( aNewMode != iInfo.iMode )

   996     {

   997     // In shutdown mode will not accept leaving ECamControllerShutdown state.

   998     TBool newModeNotAccepted = ( IsInShutdownMode() 

   999                               && ECamControllerShutdown == iInfo.iMode 

  1000                               && ECamControllerShutdown != aNewMode );

  1001     if( !newModeNotAccepted )

  1002       {

  1003       iInfo.iMode = aNewMode;

  1004       NotifyControllerObservers( ECamEventEngineStateChanged );

  1005       }

  1006     else

  1007       {

  1008       PRINT( _L("Camera <> this mode change not acceptable in shutdown mode!") );

  1009       }      

  1010     }

  1011   PRINT( _L("Camera <= CCamAppController::SetMode") );

  1012   }

  1013 

  1014 // ---------------------------------------------------------------------------

  1015 //

  1016 // ---------------------------------------------------------------------------

  1017 //

  1018 void 

  1019 CCamAppController::SetTargetMode( const TCamCameraMode& aNewMode )

  1020   {

  1021   PRINT2( _L("Camera =><= CCamAppController::SetTargetMode [%s] -> [%s]"), 

  1022           KCamModeNames[iInfo.iTargetMode],

  1023           KCamModeNames[aNewMode         ] );

  1024 

  1025   iInfo.iTargetMode = aNewMode;

  1026   }

  1027 

  1028 // ---------------------------------------------------------------------------

  1029 //

  1030 // ---------------------------------------------------------------------------

  1031 //

  1032 void 

  1033 CCamAppController::SetImageMode( const TCamImageCaptureMode& aNewMode )

  1034   {

  1035   PRINT2( _L("Camera =><= CCamAppController::SetImageMode [%s] -> [%s]"), 

  1036           KCamImageModeNames[iInfo.iImageMode],

  1037           KCamImageModeNames[aNewMode        ] );

  1038 

  1039   iInfo.iImageMode = aNewMode;

  1040   // Notify ??

  1041   }

  1042 

  1043 

  1044 // ---------------------------------------------------------------------------

  1045 //

  1046 // ---------------------------------------------------------------------------

  1047 //

  1048 void 

  1049 CCamAppController::SetTargetImageMode( const TCamImageCaptureMode& aNewMode )

  1050   {

  1051   PRINT2( _L("Camera =><= CCamAppController::SetTargetImageMode [%s] -> [%s]"), 

  1052           KCamImageModeNames[iInfo.iTargetImageMode],

  1053           KCamImageModeNames[aNewMode              ] );

  1054 

  1055   iInfo.iTargetImageMode = aNewMode;

  1056   }

  1057 

  1058 

  1059 // ---------------------------------------------------------------------------

  1060 //

  1061 // ---------------------------------------------------------------------------

  1062 //

  1063 void CCamAppController::SetOperation( TCamCaptureOperation aNewOperation, 

  1064                                       TInt                 aError /*= KErrNone*/ )

  1065   {

  1066   PRINT2( _L("Camera => CCamAppController::SetOperation: [%s] -> [%s]"), 

  1067           KCamCaptureOperationNames[iInfo.iOperation], 

  1068           KCamCaptureOperationNames[aNewOperation   ] );

  1069     PERF_OPERATION_STATE_CHANGE( aNewOperation ); 

  1070     

  1071     if( iInfo.iOperation != aNewOperation 

  1072      || aError           != KErrNone ) 

  1073       {      

  1074       iInfo.iOperation = aNewOperation;

  1075       NotifyControllerObservers( ECamEventOperationStateChanged, aError );

  1076       }

  1077 

  1078   PRINT( _L("Camera <= CCamAppController::SetOperation") );

  1079   }

  1080 

  1081 

  1082 

  1083 // ---------------------------------------------------------------------------

  1084 // CCamAppController::ImagesRemaining

  1085 // Return the number of images that can still be saved

  1086 // ---------------------------------------------------------------------------

  1087 //

  1088 TInt CCamAppController::ImagesRemaining( TCamMediaStorage aStorage,

  1089                                          TBool            aBurstActive )

  1090   {

  1091   TCamPhotoSizeId size = static_cast<TCamPhotoSizeId>

  1092         ( iSettingsModel->IntegerSettingValue( ECamSettingItemPhotoSize ) ); 

  1093 

  1094   return ImagesRemaining( aStorage, aBurstActive, size );

  1095   }

  1096 

  1097 // ---------------------------------------------------------------------------

  1098 // CCamAppController::ImagesRemaining

  1099 // Return the number of images that can still be saved

  1100 // ---------------------------------------------------------------------------

  1101 //

  1102 TInt CCamAppController::ImagesRemaining( TCamMediaStorage aStorage,

  1103                                          TBool            aBurstActive, 

  1104                                          TInt             aQualityIndex )

  1105   {

  1106   TCamPhotoSizeId size = static_cast<TCamPhotoSizeId>

  1107         ( iSettingsModel->PhotoResolution( aQualityIndex ) );

  1108 

  1109   return ImagesRemaining( aStorage, aBurstActive, size );

  1110   }

  1111 

  1112 // ---------------------------------------------------------------------------

  1113 // CCamAppController::ImagesRemaining

  1114 // Return the number of images that can still be saved

  1115 // ---------------------------------------------------------------------------

  1116 //

  1117 TInt CCamAppController::ImagesRemaining( TCamMediaStorage aStorage,

  1118                                          TBool            aBurstActive, 

  1119                                          TCamPhotoSizeId  aSize        )

  1120   {

  1121   PRINT( _L("Camera => CCamAppController::ImagesRemaining" ))

  1122   if ( ECamMediaStorageCurrent == aStorage )

  1123     {

  1124     TCamMediaStorage store_unfiltered = static_cast<TCamMediaStorage>

  1125         ( IntegerSettingValueUnfiltered( ECamSettingItemPhotoMediaStorage ) );    

  1126    

  1127     // check to see if the MMC has been removed and we are waiting on a storage switch note

  1128     // before we start returning the values for phone memory

  1129     if( ECamMediaStorageCard == store_unfiltered

  1130      && static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() )->IsMMCRemovedNotePending() 

  1131       )

  1132       {

  1133       PRINT( _L("Camera <= CCamAppController::ImagesRemaining mmc removed - returning 0" ))

  1134       return 0;// UI Behaves as if MMC is still memory in use, thus we return zero images remaining as MMC is removed