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 <akntoolbarextension.h>

    36 #include <centralrepository.h>

    37 

    38 #include <ctsydomainpskeys.h>

    39 #include <ProfileEngineSDKCRKeys.h>

    40 #include <sysutildomaincrkeys.h>

    41 #include <ScreensaverInternalPSKeys.h>

    42 #include <musresourceproperties.h>

    43 #include <cameraplatpskeys.h>

    44 #include <bitmaptransforms.h>

    45 #include <sensrvorientationsensor.h>

    46 #include <sensrvchannel.h>

    47 #include <sensrvchannelfinder.h>

    48 

    49 #include <UsbWatcherInternalPSKeys.h>

    50 #include <usbpersonalityids.h>

    51 

    52 #include <UikonInternalPSKeys.h>

    53 

    54 #include <cameraapp.rsg>

    55 #include <vgacamsettings.rsg>

    56 #include "CamSettingsInternal.hrh"

    57 #include "CamProductSpecificSettings.hrh"

    58 #include "CameraappPrivateCRKeys.h"

    59 #include "CamAppController.h"

    60 #include "CamUtility.h"

    61 #include "CamLogger.h"

    62 #include "CamSettings.hrh"

    63 #include "CamSettingsModel.h"

    64 #include "CamPanic.h"

    65 #include "CamBurstCaptureArray.h"

    66 #include "CamTimer.h"

    67 #include "CamImageSaveActive.h"

    68 #include "CamAppUi.h"

    69 #include "CamObserverHandler.h"

    70 #include "CamSelfTimer.h"

    71 #include "camflashstatus.h"

    72 

    73 #include "CamPerformance.h"

    74 #include "OstTraceDefinitions.h"

    75 #ifdef OST_TRACE_COMPILER_IN_USE

    76 #include "CamAppControllerTraces.h"

    77 #endif

    78 

    79 #include "CamVideoQualityLevel.h"

    80 #include "CamCallStateAo.h"    

    81 #include "CamPropertyWatcher.h"

    82 #include <avkondomainpskeys.h>

    83 #include <ProfileEngineInternalPSKeys.h>

    84 #include <ProfileEnginePrivatePSKeys.h>

    85 

    86 #ifndef __WINSCW__

    87   #include "rlocationtrail.h"

    88   #include "locationtrailpskeys.h"

    89 #endif

    90 //#include "camconstantsettingprovider.h"

    91 #include "camsettingprovider.h"

    92 #include "camsettingconversion.h"

    93 #include "camcamerarequests.h"

    94 #include "camcameraevents.h"

    95 #include "camcameracontrollertypes.h"

    96 #include "camcameracontroller.h"

    97 #include "cambuffershare.h"

    98 #include "cambuffersharecleanup.h"

    99 #include "camaudioplayercontroller.h"

   100 #include "camuidconstants.h"

   101 #include "camconfiguration.h"

   102 #include "CamPreCaptureViewBase.h"

   103 #include "CamPostCaptureViewBase.h"

   104 

   105 #include <cfclient.h>

   106 #include <cfcontextobject.h>

   107 #include <cfcontextquery.h>

   108 

   109 #include "camvideotime.h"

   110 #include "CamGSInterface.h"

   111 #include "CameraUiConfigManager.h"

   112 #include "camsnapshotrotator.h"

   113 #include "CamVideoPreCaptureView.h"

   114 

   115 #include <bitmaptransforms.h> 

   116 

   117 #ifdef _DEBUG

   118 #ifdef _AO_TRACKING

   119 struct CFakeActiveScheduler : public CActiveScheduler {

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

   121 };

   122 #endif // _AO_TRACKING

   123 #endif // _DEBUG

   124 

   125 // ===========================================================================

   126 // Local constants

   127 

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

   129 // with sequence mode.

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

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

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

   133 

   134 const TUint32 KCamLatestFilePath      = 0x00000001;

   135 

   136 

   137 // temporary constants until image naming is implemented

   138 _LIT( KImageExtension, ".jpg" );

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

   140 #ifndef __WINS__

   141 _LIT( KVideoMP4Extension, ".mp4" );

   142 #endif

   143 

   144 const TInt KMaxExtension = 4;

   145 //const TInt64 KBurstInterval = 0;

   146 

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

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

   149 const TInt KVideoArrayUsers = 1;

   150 const TInt KImageArrayUsers = 2;

   151 

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

   153 

   154 // UID for central repository file

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

   156 

   157 const TInt KMicroSecsInMilliSec = 1000;

   158 const TInt KSecondInMicSec = 1000000;

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

   160 const TInt KLocTrailCloseRetryTime = 5 * KSecondInMicSec;

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

   162 

   163 // Estimated time needed to complete autofocus

   164 const TInt KFocusingDurationSeconds = 2;

   165 

   166 const TInt KCCorFocused = 0x00000002;

   167 

   168 const TInt KCamMaxDateLen = 8;

   169 

   170 static const TInt KTimelapseArrayGranularity = 6;

   171 

   172 // Backlight / Inactivity timer related

   173 //   Callback interval is set to 4s. 

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

   175 static const TInt KBacklighTimerPriority = CActive::EPriorityHigh;

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

   177 

   178 // Camera Controller events interest.

   179 //   Want to receive all events.

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

   181 static const TUint KCamEventInterest = (  ECamCameraEventClassAll );

   182 

   183 static const TInt KLensCoverDelay = 500*1000;

   184 

   185 _LIT( KCamContextSource, "Application" );

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

   187 _LIT( KCamContextValueEnable, "Enabled" );

   188 _LIT( KCamContextValueDisable, "Disabled" );

   189 _LIT_SECURITY_POLICY_PASS( KCamContextSecurity );

   190 

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

   192 // ===========================================================================

   193 // Local namespace

   194 namespace NCamAppController

   195   {

   196   // -------------------------------------------------------

   197   // Request sequences 

   198 //  static const TCamCameraRequestId KCamSequencePowerOffOn[] = 

   199 //    { 

   200 //    ECamRequestPowerOff, 

   201 //    ECamRequestPowerOn

   202 //    };

   203   

   204   // -------------------------------------------------------

   205   // Local methods

   206 

   207   inline TInt ResetBitmap( CFbsBitmap*& aBitmap )

   208     {

   209     if( aBitmap )

   210       {

   211       aBitmap->Reset();

   212       return KErrNone;

   213       }

   214     else

   215       {

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

   217       return create;

   218       }

   219     };

   220 

   221   inline void ClearSequenceBusyFlag( TAny* aBusyFlags )

   222     {

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

   224     if( flags )

   225       {

   226       *flags &= ~EBusySequence;

   227       }

   228     };

   229 

   230   inline void ClearRequestBusyFlag( TAny* aBusyFlags )

   231     {

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

   233     if( flags )

   234       {

   235       *flags &= ~EBusyRequest;

   236       }

   237     };

   238   }

   239 

   240 #include "camflagutility.inl"

   241 #include "campointerutility.inl"

   242 

   243 using namespace NCamAppController;

   244 using namespace NCamCameraController;

   245 // ===========================================================================

   246 

   247 

   248 // ===========================================================================

   249 // Member functions

   250 

   251 // ---------------------------------------------------------------------------

   252 // CCamAppController::NewL

   253 // Two-phased constructor.

   254 // ---------------------------------------------------------------------------

   255 //

   256 CCamAppController* CCamAppController::NewL()

   257     {

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

   259     CleanupStack::PushL( self );

   260     self->ConstructL();

   261     CleanupStack::Pop( self );

   262     return self;

   263     }

   264 

   265 

   266 // ---------------------------------------------------------------------------

   267 // CCamAppController::CompleteConstructionL

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

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

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

   271 // ---------------------------------------------------------------------------

   272 //    

   273 void CCamAppController::CompleteConstructionL()

   274   {

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

   276 

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

   278   

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

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

   281 

   282   TInt index = 0;

   283   iInfo.iActiveCamera = ECamActiveCameraPrimary;

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

   285   

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

   287   iSettingsModel->StorePrimaryCameraSettingsL();

   288 

   289 

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

   291   if ( iConfigManager->IsLensCoverSupported() )

   292       {

   293       // Request notification of slide state changes

   294       iSlideStateWatcher->Subscribe();

   295 

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

   297       // there are any errors.

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

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

   300       TInt requiredOrientation;

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

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

   303         {

   304         if ( appUi->IsQwerty2ndCamera() )

   305             {  

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

   307             index = 1;

   308             iInfo.iActiveCamera = ECamActiveCameraSecondary;

   309             CCamAppUi* appUi = static_cast<CCamAppUi*>( 

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

   311             // We may have primary camera settings loaded 

   312             LoadStaticSettingsL( appUi->IsEmbedded() );   

   313             CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, 

   314                                    requiredOrientation );

   315             }

   316         else

   317             {

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

   319             appUi->HandleCommandL( EEikCmdExit);

   320             }

   321         }

   322       else  

   323         {  

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

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

   326         if ( ( iSlideState == CameraPlatPSKeys::EClosed               

   327               || slideErr    != KErrNone )

   328               && CamerasAvailable() > 1 )

   329           {

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

   331           index = 1;

   332           iInfo.iActiveCamera = ECamActiveCameraSecondary;

   333           CamUtility::GetPsiInt( ECamPsiSecondaryCameraOrientation, requiredOrientation );

   334           }

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

   336           {

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

   338           index = 0;

   339           iInfo.iActiveCamera = ECamActiveCameraPrimary;

   340 

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

   342           //so need to fix orientation

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

   344             {

   345             TInt primaryOrientation;

   346             CamUtility::GetPsiInt( ECamPsiPrimaryCameraOrientation, 

   347                                       primaryOrientation );

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

   349             appUi->SetCamOrientationToLandscape();

   350             }

   351           }   

   352         }

   353       }

   354 

   355   ConstructCameraControllerL( index );

   356   

   357   // Send startup sequence ?

   358 

   359   /**

   360    * Removed all custom interfaces requested from engine

   361    */

   362   iAccSensorListening = EFalse;

   363 

   364   iCallStateAo = CCamCallStateAo::NewL( this );             

   365   

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

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

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

   369   // already higher).

   370   iBacklightTimer = CPeriodic::NewL( KBacklighTimerPriority );

   371 

   372 #ifdef _DEBUG

   373 #ifdef _AO_TRACKING

   374   TAny *iAoBacklightTimer = (TAny *)iBacklightTimer;

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

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

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

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

   379 #endif // _AO_TRACKING

   380 #endif // _DEBUG

   381 

   382 #ifdef _DEBUG

   383 #ifdef _AO_TRACKING

   384   TAny *iAoDeepSleepTimer = (TAny *)iDeepSleepTimer;

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

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

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

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

   389 #endif // _AO_TRACKING

   390 #endif // _DEBUG

   391 

   392 

   393   if ( UiConfigManagerPtr()->IsXenonFlashSupported() )

   394       {

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

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

   397       }

   398 

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

   400   }    

   401 

   402 

   403 // ---------------------------------------------------------------------------

   404 // 

   405 // ---------------------------------------------------------------------------

   406 //

   407 TInt 

   408 CCamAppController::GetCriticalMemoryLevelL( const TCamMediaStorage& aStorage )

   409   {

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

   411 

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

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

   414   if( KErrNotFound == iRamDiskCriticalLevel

   415    || KErrNotFound == iDiskCriticalLevel   )

   416     {

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

   418     TInt err;

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

   420     if ( KErrNone != err )

   421       {

   422       CamPanic( ECamPanicDefaultNotFoundInIniFile );      

   423       }

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

   425     if ( KErrNone != err )

   426       {

   427       CamPanic( ECamPanicDefaultNotFoundInIniFile ); 

   428       } 

   429     CleanupStack::PopAndDestroy( repository );

   430     }

   431   

   432   TInt level = ( aStorage == ECamMediaStoragePhone ) 

   433              ? iRamDiskCriticalLevel

   434              : iDiskCriticalLevel;

   435 

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

   437   return level;

   438   }

   439 

   440 // ---------------------------------------------------------------------------

   441 // CCamAppController::~CCamAppController

   442 // Destructor

   443 // ---------------------------------------------------------------------------

   444 //

   445 CCamAppController::~CCamAppController()

   446   { 

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

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

   449   EnableScreenSaver( ETrue );

   450 

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

   452   

   453   if ( iFlashStatus )

   454     {

   455     delete iFlashStatus;

   456     }

   457 

   458   delete iSoundPlayer;

   459 

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

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

   462   iControllerObservers.Close();

   463 

   464   delete iCallStateAo;    

   465 

   466   delete iBurstTimer;

   467 

   468 // Using timer also on bitmap mode.

   469   if( iBacklightTimer )

   470     {

   471     iBacklightTimer->Cancel();

   472     delete iBacklightTimer;

   473     }

   474 

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

   476     		iAccSensorListening )

   477         {

   478         iAccSensorChannel->StopDataListening();

   479         iAccSensorChannel->CloseChannel();

   480         }

   481     delete iAccSensorChannel;

   482 

   483   if ( iSlideStateWatcher )

   484     {

   485     iSlideStateWatcher->Cancel();

   486     delete iSlideStateWatcher;

   487     }

   488   

   489   if ( iSliderCallBack )

   490     { 

   491     iSliderCallBack->Cancel();

   492     delete iSliderCallBack;

   493     iSliderCallBack = NULL;

   494     }

   495 

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

   497     {

   498     iKeyLockStatusWatcher->Cancel();

   499     delete iKeyLockStatusWatcher;

   500     }

   501   

   502   if ( iProfileStatusWatcher )

   503       {

   504       iProfileStatusWatcher->Cancel();

   505       delete iProfileStatusWatcher;

   506       }

   507   

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

   509       {

   510       TRAP_IGNORE ( PublishZoomStateL( EFalse ) );

   511       delete iContextFwClient;      

   512       }

   513 

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

   515     {

   516     if( iLocationTrailTimer )

   517       {

   518       iLocationTrailTimer->Cancel();

   519       delete iLocationTrailTimer;

   520       iLocationTrailTimer = NULL;

   521       }

   522     }

   523       

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

   525     {

   526     // stop trail and close session

   527     StopLocationTrail( ETrue );

   528     }

   529 

   530   if ( iImageSaveActive )  

   531     {

   532       iImageSaveActive->ForceCancel();

   533     delete iImageSaveActive;

   534     }

   535 

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

   537   delete iSettingsModel;  // Must be before iEngine deleted

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

   539   iPreviewRollbacks.Close();

   540 

   541 

   542   delete iCaptureArray;

   543   delete iRotationArray;

   544   if ( iSequenceFilenameArray )

   545     {

   546     iSequenceFilenameArray->Reset();

   547     delete iSequenceFilenameArray;

   548     }    

   549 

   550   if( iDeepSleepTimer )

   551     {

   552     iDeepSleepTimer->Cancel();

   553     delete iDeepSleepTimer;

   554     }

   555 

   556   if( iIdleTimer )

   557     {

   558     iIdleTimer->Cancel();

   559     delete iIdleTimer;

   560     }

   561 

   562   if ( iTimeLapseTimer )

   563     {

   564     iTimeLapseTimer->Cancel();

   565     delete iTimeLapseTimer;

   566     }

   567 

   568   if( iCaptureToneDelayTimer )

   569     {

   570     iCaptureToneDelayTimer->Cancel();

   571     delete iCaptureToneDelayTimer;

   572     }

   573 

   574   delete iCaptureCompletionObserverHandler;      

   575   delete iSnapShotCopy; 

   576     

   577   iJpegDataSizes.Close();

   578   iSequencePostProcessDataSizes.Close();

   579   

   580   // Close the arrays

   581   iPendingObserversArray.Close();

   582   iCameraEventInterested.Close();

   583 

   584   // Controller handles releasing CCamera if needed.

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

   586   delete iCameraController;

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

   588   delete iSettingProvider;

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

   590   

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

   592   delete iConfiguration;

   593   iConfiguration = NULL;  

   594 

   595   RProperty::Delete( KPSUidCamcorderNotifier, KCCorFocused );  

   596     if( iPlugin )

   597         {

   598         // Destroy Ecom plugin

   599         iPlugin->DestroyPlugin();

   600         }

   601   iPlugin = NULL;

   602   delete iDriveChangeNotifier;

   603   iFs.Close();

   604   

   605   if( iRotatorAo )

   606       {

   607       delete iRotatorAo;

   608       }

   609 

   610   delete iSnapShotRotator;

   611   

   612   if( iTvAccessoryMonitor )

   613       {

   614       delete iTvAccessoryMonitor;

   615       iTvAccessoryMonitor = NULL;

   616       }

   617   

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

   619   }

   620 

   621 

   622 // ---------------------------------------------------------------------------

   623 // CCamAppController::SavedCurrentImage

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

   625 // ---------------------------------------------------------------------------

   626 //

   627 TBool CCamAppController::SavedCurrentImage() const

   628   {

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

   630   TBool saved( ETrue );

   631 

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

   633   if( iImageSaveRequestPending )

   634     {

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

   636     saved = EFalse;

   637     }

   638   else if( CurrentFullFileName() == KNullDesC )

   639     {

   640     saved = EFalse;

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

   642     }

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

   644             iCaptureArray->CurrentlySavingFile( CurrentFullFileName() ) )

   645     {

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

   647     saved = EFalse;

   648     }

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

   650     {

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

   652    	saved = EFalse;    

   653     }

   654   else

   655     {

   656     // empty

   657     }

   658 

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

   660   return saved;

   661   }

   662 

   663 // ---------------------------------------------------------------------------

   664 // CCamAppController::RenameCurrentFileL

   665 // Rename image/video.

   666 // ---------------------------------------------------------------------------

   667 //

   668 TBool 

   669 CCamAppController::RenameCurrentFileL( const TDesC&          aNewName, 

   670                                        const TCamCameraMode& /*aMode*/ )

   671   {

   672   TBool status = EFalse;

   673 

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

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

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

   677     {                

   678     // Rename the file.

   679     TFileName filePath = CurrentFullFileName();

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

   681     

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

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

   684     

   685     status = ETrue;

   686     }

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

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

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

   690     {

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

   692     // ...determine new path.

   693     TParsePtrC parse( CurrentFullFileName() );

   694     TFileName fullNewPath;

   695     fullNewPath = parse.DriveAndPath();

   696     fullNewPath.Append( aNewName );

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

   698 

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

   700 

   701     status = ETrue;

   702     }

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

   704   // so that renaming must wait until completed.

   705   else

   706     {

   707     // Leave status to EFalse

   708     }

   709     

   710   return status;

   711   }

   712 

   713 

   714 // ---------------------------------------------------------------------------

   715 // CCamAppController::AddControllerObserverL

   716 // Add a controller observer.

   717 // ---------------------------------------------------------------------------

   718 //

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

   720   {

   721   if( aObserver &&

   722       KErrNotFound == iControllerObservers.Find( aObserver ) )

   723     {

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

   725     }

   726   }

   727 

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

   729 // CCamAppController::RemoveControllerObserver

   730 // Remove a controller observer.

   731 // ---------------------------------------------------------------------------

   732 //

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

   734   {

   735   // Errors ignored

   736   if( aObserver )

   737     {

   738     TInt index = iControllerObservers.Find( aObserver );

   739     if( KErrNotFound != index )

   740       {

   741       iControllerObservers.Remove( index );

   742       }

   743     }

   744   }

   745 

   746 // ---------------------------------------------------------------------------

   747 // AddCameraObserverL

   748 // ---------------------------------------------------------------------------

   749 //

   750 void 

   751 CCamAppController

   752 ::AddCameraObserverL( const MCamCameraObserver* aObserver, 

   753                       const TUint&              aEventInterest )

   754   {

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

   756 

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

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

   759       {  

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

   761 

   762       iPendingObserversArray.AppendL( aObserver );

   763       iCameraEventInterested.AppendL( aEventInterest );

   764       }

   765 

   766   if( iCameraController )

   767       {

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

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

   770               iCameraEventInterested.Count() > 0 )

   771           {

   772           const MCamCameraObserver* camEventObserver = iPendingObserversArray[0];

   773           TUint eventInterest = iCameraEventInterested[0];

   774           iCameraController->AttachObserverL( camEventObserver, eventInterest );

   775           iPendingObserversArray.Remove( 0 );

   776           iCameraEventInterested.Remove( 0 );

   777           } 

   778       }

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

   780   }

   781 

   782 // ---------------------------------------------------------------------------

   783 // RemoveCameraObserver

   784 // ---------------------------------------------------------------------------

   785 //

   786 void 

   787 CCamAppController

   788 ::RemoveCameraObserver( const MCamCameraObserver* aObserver )

   789   {

   790   if( iCameraController )

   791     iCameraController->DetachObserver( aObserver );

   792   }

   793 

   794 // ---------------------------------------------------------------------------

   795 // AddSettingsObserverL

   796 // ---------------------------------------------------------------------------

   797 //

   798 void

   799 CCamAppController

   800 ::AddSettingsObserverL( const MCamSettingsModelObserver* aObserver )

   801   {

   802   if( iSettingsModel )

   803     iSettingsModel->AttachObserverL( aObserver );

   804   else

   805     User::Leave( KErrNotReady );

   806   }

   807 

   808 // ---------------------------------------------------------------------------

   809 // RemoveCameraObserver

   810 // ---------------------------------------------------------------------------

   811 //

   812 void 

   813 CCamAppController

   814 ::RemoveSettingsObserver( const MCamSettingsModelObserver* aObserver )

   815   {

   816   if( iSettingsModel )

   817     iSettingsModel->DetachObserver( aObserver );

   818   }

   819 

   820 

   821 // ---------------------------------------------------------------------------

   822 //

   823 // ---------------------------------------------------------------------------

   824 //

   825 void 

   826 CCamAppController::ConstructCameraControllerL( TInt aCameraIndex )

   827   {

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

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

   830   PERF_EVENT_START_L2( EPerfEventCAEConstruction );

   831 

   832   if( !iCameraController )

   833     {

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

   835                                                     aCameraIndex ); 

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

   837     // to be finished here                                                    

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

   839       {

   840       iCameraController->CompleteSwitchCameraL();

   841       }

   842     }

   843 

   844   // Attach as Camera Controller observer to get events

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

   846   iCameraController->AttachObserverL( this, KCamEventInterest );

   847 

   848 

   849   PERF_EVENT_END_L2( EPerfEventCAEConstruction );

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

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

   852   }

   853 

   854 // #################################################################################################

   855 

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

   857 // Returns the current camera controller state

   858 // (Bitfield of type TCamCameraStateFlags )

   859 // ---------------------------------------------------------------------------

   860 //

   861 TUint

   862 CCamAppController::CameraControllerState() const

   863   {

   864   TUint state( ECamIdle );

   865   if( iCameraController )

   866     {

   867     state = iCameraController->State();

   868     }

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

   870   return state;

   871   }

   872   

   873 // ---------------------------------------------------------------------------

   874 // Returns the current camera state

   875 // (TCamCameraState)

   876 // ---------------------------------------------------------------------------

   877 //

   878 TCamCameraState

   879 CCamAppController::CameraState() const

   880   {

   881   TCamCameraState state( ECamCameraIdle );  

   882   

   883   TUint controllerState = CameraControllerState();

   884  

   885   // Convert controller state to TCamCameraState

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

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

   888   if( IsFlagOn( controllerState, ECamImageOn ) )

   889     {

   890     state = ECamCameraPreparedImage;

   891     }

   892   else if( IsFlagOn( controllerState, ECamVideoOn ) )

   893     {

   894     state = ECamCameraPreparedVideo;  

   895     }

   896   else if( IsFlagOn( controllerState, ECamPowerOn ) )  

   897     {

   898     state = ECamCameraPowerOn;  

   899     }

   900   else if( IsFlagOn( controllerState, ECamReserved ) )  

   901     {

   902     state = ECamCameraReserved;  

   903     }

   904     

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

   906   return state;

   907   }  

   908 

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

   910 //

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

   912 //

   913 TCamCameraMode

   914 CCamAppController::CurrentMode() const

   915   {

   916   PRINT1( _L("Camera <> CCamAppController::CurrentMode:%d"), iInfo.iMode );

   917   return iInfo.iMode;

   918   }

   919 

   920 // ---------------------------------------------------------------------------

   921 //

   922 // ---------------------------------------------------------------------------

   923 //

   924 TCamCameraMode

   925 CCamAppController::TargetMode() const

   926   {

   927   return iInfo.iTargetMode;

   928   }

   929 

   930 // ---------------------------------------------------------------------------

   931 //

   932 // ---------------------------------------------------------------------------

   933 //

   934 // CCamAppController::CurrentCaptureModeSetup()

   935 TCamImageCaptureMode

   936 CCamAppController::CurrentImageModeSetup() const

   937   {

   938   TCamImageCaptureMode captureMode = ECamImageCaptureSingle; 

   939   if( IsAppUiAvailable() ) 

   940     { 

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

   942     if ( appUi->IsBurstEnabled() ) 

   943       { 

   944       captureMode = appUi->CurrentBurstMode(); 

   945       } 

   946     } 

   947   return captureMode; 

   948   }

   949 

   950 // ---------------------------------------------------------------------------

   951 //

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

   953 //

   954 TCamCaptureOperation

   955 CCamAppController::CurrentOperation() const

   956   {

   957   return iInfo.iOperation;

   958   }

   959 

   960 // ---------------------------------------------------------------------------

   961 //

   962 // ---------------------------------------------------------------------------

   963 //

   964 TCamCaptureOperation

   965 CCamAppController::CurrentImageOperation() const

   966   {

   967   if( ECamControllerImage == iInfo.iMode )

   968     return iInfo.iOperation;

   969   else

   970     return ECamNoOperation;

   971   }

   972 

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

   974 //

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

   976 //

   977 TCamCaptureOperation  

   978 CCamAppController::CurrentVideoOperation() const

   979   {

   980   if( ECamControllerVideo == iInfo.iMode )

   981     return iInfo.iOperation;

   982   else

   983     return ECamNoOperation;

   984   }

   985 

   986 // ---------------------------------------------------------------------------

   987 //

   988 // ---------------------------------------------------------------------------

   989 //

   990 TCamImageCaptureMode  CCamAppController::CurrentImageMode() const

   991     {

   992     return iInfo.iImageMode;

   993     }

   994 // ---------------------------------------------------------------------------

   995 //

   996 // ---------------------------------------------------------------------------

   997 //

   998 TCamCameraTriState CCamAppController::ViewfinderTargetState() const

   999   {

  1000   return iInfo.iTargetVfState;

  1001   }

  1002 

  1003 

  1004 // ---------------------------------------------------------------------------

  1005 //

  1006 // ---------------------------------------------------------------------------

  1007 //

  1008 void 

  1009 CCamAppController::SetMode( const TCamCameraMode& aNewMode )

  1010   {

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

  1012           KCamModeNames[iInfo.iMode], 

  1013           KCamModeNames[aNewMode],

  1014           KCamModeNames[iInfo.iTargetMode] );

  1015 

  1016   if( aNewMode != iInfo.iMode )

  1017     {

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

  1019     TBool newModeNotAccepted = ( IsInShutdownMode() 

  1020                               && ECamControllerShutdown == iInfo.iMode 

  1021                               && ECamControllerShutdown != aNewMode );

  1022     if( !newModeNotAccepted )

  1023       {

  1024       iInfo.iMode = aNewMode;

  1025       NotifyControllerObservers( ECamEventEngineStateChanged );

  1026       }

  1027     else

  1028       {

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

  1030       }      

  1031     }

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

  1033   }

  1034 

  1035 // ---------------------------------------------------------------------------

  1036 //

  1037 // ---------------------------------------------------------------------------

  1038 //

  1039 void 

  1040 CCamAppController::SetTargetMode( const TCamCameraMode& aNewMode )

  1041   {

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

  1043           KCamModeNames[iInfo.iTargetMode],

  1044           KCamModeNames[aNewMode         ] );

  1045 

  1046   iInfo.iTargetMode = aNewMode;

  1047   }

  1048 

  1049 // ---------------------------------------------------------------------------

  1050 //

  1051 // ---------------------------------------------------------------------------

  1052 //

  1053 void 

  1054 CCamAppController::SetImageMode( const TCamImageCaptureMode& aNewMode )

  1055   {

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

  1057           KCamImageModeNames[iInfo.iImageMode],

  1058           KCamImageModeNames[aNewMode        ] );

  1059 

  1060   iInfo.iImageMode = aNewMode;

  1061   // Notify ??

  1062   }

  1063 

  1064 

  1065 // ---------------------------------------------------------------------------

  1066 //

  1067 // ---------------------------------------------------------------------------

  1068 //

  1069 void 

  1070 CCamAppController::SetTargetImageMode( const TCamImageCaptureMode& aNewMode )

  1071   {

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

  1073           KCamImageModeNames[iInfo.iTargetImageMode],

  1074           KCamImageModeNames[aNewMode              ] );

  1075 

  1076   iInfo.iTargetImageMode = aNewMode;

  1077   }

  1078 

  1079 

  1080 // ---------------------------------------------------------------------------

  1081 //

  1082 // ---------------------------------------------------------------------------

  1083 //

  1084 void CCamAppController::SetOperation( TCamCaptureOperation aNewOperation, 

  1085                                       TInt                 aError /*= KErrNone*/ )

  1086   {

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

  1088           KCamCaptureOperationNames[iInfo.iOperation], 

  1089           KCamCaptureOperationNames[aNewOperation   ] );

  1090     PERF_OPERATION_STATE_CHANGE( aNewOperation ); 

  1091     

  1092     if( iInfo.iOperation != aNewOperation 

  1093      || aError           != KErrNone ) 

  1094       {      

  1095       iInfo.iOperation = aNewOperation;

  1096       NotifyControllerObservers( ECamEventOperationStateChanged, aError );

  1097       if( aNewOperation == ECamStandby )

  1098           {

  1099           ClearSequenceBusyFlag( &iBusyFlags );

  1100           TCamControllerInfo& info = const_cast<TCamControllerInfo&>( iCameraController->ControllerInfo() );

  1101           ClearFlags( info.iBusy , ECamBusySequence );

  1102           }

  1103       }

  1104 

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

  1106   }

  1107 

  1108 

  1109 

  1110 // ---------------------------------------------------------------------------

  1111 // CCamAppController::ImagesRemaining

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

  1113 // ---------------------------------------------------------------------------

  1114 //

  1115 TInt CCamAppController::ImagesRemaining( TCamMediaStorage aStorage,

  1116                                          TBool            aBurstActive )

  1117   {

  1118   TCamPhotoSizeId size = static_cast<TCamPhotoSizeId>

  1119         ( iSettingsModel->IntegerSettingValue( ECamSettingItemPhotoSize ) ); 

  1120 

  1121   return ImagesRemaining( aStorage, aBurstActive, size );

  1122   }

  1123 

  1124 // ---------------------------------------------------------------------------

  1125 // CCamAppController::ImagesRemaining

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

  1127 // ---------------------------------------------------------------------------

  1128 //

  1129 TInt CCamAppController::ImagesRemaining( TCamMediaStorage aStorage,

  1130                                          TBool            aBurstActive, 

  1131                                          TInt             aQualityIndex )

  1132   {

  1133   TCamPhotoSizeId size = static_cast<TCamPhotoSizeId>

  1134         ( iSettingsModel->PhotoResolution( aQualityIndex ) );