--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommscontroller/mmcccontroller/src/mcccamerahandler.cpp Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,941 @@
+/*
+* Copyright (c) 2006 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:
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include <e32svr.h>
+
+#include "mcccamerahandler.h"
+#include "mccscreen.h"
+#include "mcccontrollerlogs.h"
+#include "mccresources.h"
+#include "mcctimermanager.h"
+
+
+// EXTERNAL DATA STRUCTURES
+
+// EXTERNAL FUNCTION PROTOTYPES
+
+// CONSTANTS
+
+const TInt KMccCameraHandlerValueNotAssigned = KMaxTInt;
+
+
+// MACROS
+
+#define MCC_ASSERT_CAMERA_VAL_L( a ) \
+__ASSERT_ALWAYS( a != KMccCameraHandlerValueNotAssigned, User::Leave( KErrNotReady ) );
+
+#define MCC_USE_CAMERA( func_call ) \
+if ( iCamera ) { iCamera->func_call; }
+
+#define MCC_USE_READY_CAMERA( func_call ) \
+if ( iCamera && IsCameraReady() ) { iCamera->func_call; }
+
+#define MCC_USE_SCREEN( func_call ) \
+if ( iScreen ) { iScreen->func_call; }
+
+// LOCAL CONSTANTS AND MACROS
+
+// MODULE DATA STRUCTURES
+
+// LOCAL FUNCTION PROTOTYPES
+
+// FORWARD DECLARATIONS
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::CMccCameraHandler
+// -----------------------------------------------------------------------------
+//
+CMccCameraHandler::CMccCameraHandler(
+ MMccResources& aResources, TInt aCameraIndex, TInt aPriority ):
+ iResources( aResources ),
+ iState( EInit ),
+ iPriority( aPriority ),
+ iCameraIndex( aCameraIndex ),
+ iZoom( KMccCameraHandlerValueNotAssigned ),
+ iDigitalZoom( KMccCameraHandlerValueNotAssigned ),
+ iContrast( KMccCameraHandlerValueNotAssigned ),
+ iBrightness( KMccCameraHandlerValueNotAssigned ),
+ iWhiteBalance( KMccCameraHandlerValueNotAssigned ),
+ iExposure( KMccCameraHandlerValueNotAssigned )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::~CMccCameraHandler
+// -----------------------------------------------------------------------------
+//
+CMccCameraHandler::~CMccCameraHandler()
+ {
+ __CONTROLLER( "CMccCameraHandler::~CMccCameraHandler" )
+
+ NotifyObservers( KErrCancel );
+
+ iObservers.Reset();
+ iObservers.Close();
+
+ DoReleaseCamera();
+ DoReleaseScreen();
+
+
+#ifdef MCC_CAMERAHANDLER_TEST
+ RemoveDependencyFile();
+#endif
+
+ __CONTROLLER( "CMccCameraHandler::~CMccCameraHandler, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::NewL
+// -----------------------------------------------------------------------------
+//
+CMccCameraHandler* CMccCameraHandler::NewL(
+ MMccResources& aResources, TInt aCameraIndex, TInt aPriority )
+ {
+ CMccCameraHandler* self =
+ new ( ELeave ) CMccCameraHandler( aResources, aCameraIndex, aPriority );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ConstructL()
+ {
+ __CONTROLLER( "CMccCameraHandler::ConstructL" )
+
+#ifdef MCC_CAMERAHANDLER_TEST
+ CreateDependencyFileL();
+#endif
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::EnableViewFinderL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::EnableViewFinderL( TMccVideoSinkSetting& aSetting )
+ {
+ __CONTROLLER( "CMccCameraHandler::EnableViewFinderL" )
+
+ if ( iScreen && SettingsChanged( aSetting ) )
+ {
+ DoReleaseScreen();
+ }
+
+ iViewFinderSettings = aSetting;
+
+ __CONTROLLER( "CMccCameraHandler::EnableViewFinderL, starting vf" )
+
+ CCamera* cam = IsCameraReady() ? iCamera : NULL;
+ if ( !iScreen )
+ {
+ __CONTROLLER( "CMccCameraHandler::EnableViewFinderL, starting window" )
+ __CONTROLLER_INT2( "CMccCameraHandler::EnableViewFinderL, location",
+ iViewFinderSettings.iLocation.iX,
+ iViewFinderSettings.iLocation.iY)
+ iScreen = CMccScreen::NewL( cam,
+ iViewFinderSettings.iLocation,
+ iViewFinderSettings.iSize,
+ iViewFinderSettings.iDeviceIndex,
+ iViewFinderSettings.iWindowOrdinalPosition,
+ iViewFinderSettings.iWindowOrdinalPriority );
+ }
+ else
+ {
+ User::LeaveIfError( iScreen->SetCamera( cam ) );
+ }
+
+ iScreen->StartL();
+
+ iViewFinderEnabled = ETrue;
+
+ __CONTROLLER( "CMccCameraHandler::EnableViewFinderL, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::DisableViewFinderL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::DisableViewFinderL()
+ {
+ __CONTROLLER( "CMccCameraHandler::DisableViewFinderL" )
+
+ DoReleaseScreen();
+
+ iViewFinderEnabled = EFalse;
+
+ __CONTROLLER( "CMccCameraHandler::DisableViewFinderL, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::IsViewFinderEnabled
+// -----------------------------------------------------------------------------
+//
+TBool CMccCameraHandler::IsViewFinderEnabled() const
+ {
+ // Zero size vf is considered as disabled
+ return ( iViewFinderEnabled &&
+ ( iViewFinderSettings.iSize.iHeight != 0 ||
+ iViewFinderSettings.iSize.iWidth != 0 ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::GetViewFinderSettingsL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::GetViewFinderSettingsL( TMccVideoSinkSetting& aSetting )
+ {
+ __CONTROLLER( "CMccCameraHandler::GetViewFinderSettingsL" )
+ __CONTROLLER_INT2( "CMccCameraHandler::GetViewFinderSettingsL, size",
+ iViewFinderSettings.iSize.iHeight,
+ iViewFinderSettings.iSize.iWidth)
+ __CONTROLLER_INT2( "CMccCameraHandler::GetViewFinderSettingsL, location",
+ iViewFinderSettings.iLocation.iX,
+ iViewFinderSettings.iLocation.iY)
+ aSetting = iViewFinderSettings;
+ __CONTROLLER( "CMccCameraHandler::GetViewFinderSettingsL,exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::GetCamInfoL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::GetCamInfoL( TCameraInfo& aInfo, TBool aForceCameraCreation )
+ {
+ __CONTROLLER( "CMccCameraHandler::GetCamInfoL" )
+
+ TBool removeTemporaryCamera( EFalse );
+ if ( aForceCameraCreation && !iCamera )
+ {
+ iCamera = CreateCameraL();
+ removeTemporaryCamera = ETrue;
+ }
+
+ __ASSERT_ALWAYS( iCamera, User::Leave( KErrNotReady ) );
+
+ iCamera->CameraInfo( aInfo );
+
+ if ( removeTemporaryCamera )
+ {
+ delete iCamera;
+ iCamera = 0;
+ }
+
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, orientation", aInfo.iOrientation )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, options", aInfo.iOptionsSupported )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, flash modes", aInfo.iFlashModesSupported )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, exposure modes", aInfo.iExposureModesSupported )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, white balance modes", aInfo.iWhiteBalanceModesSupported )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, min zoom", aInfo.iMinZoom )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, max zoom", aInfo.iMaxZoom )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, max digital zoom", aInfo.iMaxDigitalZoom )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, min zoom factor", aInfo.iMinZoomFactor )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, max zoom factor", aInfo.iMaxZoomFactor )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, max digital zoom factor", aInfo.iMaxDigitalZoomFactor )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, image sizes", aInfo.iNumImageSizesSupported )
+ __CONTROLLER_INT1( "CMccCameraHandler::GetCamInfoL, image formats", aInfo.iImageFormatsSupported )
+
+ __CONTROLLER( "CMccCameraHandler::GetCamInfoL, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::GetNumOfCamerasL
+// -----------------------------------------------------------------------------
+//
+TInt CMccCameraHandler::GetNumOfCamerasL()
+ {
+ __CONTROLLER( "CMccCameraHandler::GetNumOfCamerasL" )
+
+ TInt count = CCamera::CamerasAvailable();
+
+ __CONTROLLER_INT1( "CMccCameraHandler::GetNumOfCamerasL, count ", count )
+ __CONTROLLER( "CMccCameraHandler::GetNumOfCamerasL, exit" )
+ return count;
+ }
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::GetValue
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::GetValueL( TUint32 aParam, TInt& aVal )
+ {
+ __CONTROLLER( "CMccCameraHandler::GetValue" )
+ switch( aParam )
+ {
+ case KMccCamZoomFactor:
+ {
+ TInt temp = iCamera ? iCamera->ZoomFactor() : iZoom;
+ MCC_ASSERT_CAMERA_VAL_L( temp )
+ aVal = temp;
+ break;
+ }
+ case KMccCamDigitZoomFactor:
+ {
+ TInt temp = iCamera ? iCamera->DigitalZoomFactor() : iDigitalZoom;
+ MCC_ASSERT_CAMERA_VAL_L( temp )
+ aVal = temp;
+ break;
+ }
+ case KMccCamContrast:
+ {
+ TInt temp = iCamera ? iCamera->Contrast() : iContrast;
+ MCC_ASSERT_CAMERA_VAL_L( temp )
+ aVal = temp;
+ break;
+ }
+ case KMccCamBrightness:
+ {
+ TInt temp = iCamera ? iCamera->Brightness() : iBrightness;
+ MCC_ASSERT_CAMERA_VAL_L( temp )
+ aVal = temp;
+ break;
+ }
+ case KMccCamWhiteBalance:
+ {
+ TInt temp = iCamera ? iCamera->WhiteBalance() : iWhiteBalance;
+ MCC_ASSERT_CAMERA_VAL_L( temp )
+ aVal = temp;
+ break;
+ }
+ case KMccCamExposure:
+ {
+ TInt temp = iCamera ? iCamera->Exposure() : iExposure;
+ MCC_ASSERT_CAMERA_VAL_L( temp )
+ aVal = temp;
+ break;
+ }
+ default:
+ {
+ User::Leave( KErrNotSupported );
+ break;
+ }
+ }
+ __CONTROLLER_INT2( "CMccCameraHandler::GetValue, param, value", aParam, aVal )
+ __CONTROLLER( "CMccCameraHandler::GetValue, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::SetValue
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::SetValueL( TUint32 aParam, TInt aVal )
+ {
+ __CONTROLLER( "CMccCameraHandler::SetValue" )
+
+ if ( aVal == KMccCameraHandlerValueNotAssigned )
+ {
+ __CONTROLLER( "CMccCameraHandler::SetValue, value not assigned, exit" )
+ return;
+ }
+
+ __CONTROLLER_INT2( "CMccCameraHandler::SetValue, param, value", aParam, aVal )
+ switch( aParam )
+ {
+ case KMccCamZoomFactor:
+ MCC_USE_CAMERA( SetZoomFactorL( aVal ) )
+ iZoom = aVal;
+ break;
+ case KMccCamDigitZoomFactor:
+ MCC_USE_CAMERA( SetDigitalZoomFactorL( aVal ) )
+ iDigitalZoom = aVal;
+ break;
+ case KMccCamContrast:
+ MCC_USE_CAMERA( SetContrastL( aVal ) )
+ iContrast = aVal;
+ break;
+ case KMccCamBrightness:
+ MCC_USE_CAMERA( SetBrightnessL( aVal ) )
+ iBrightness = aVal;
+ break;
+ case KMccCamWhiteBalance:
+ MCC_USE_CAMERA( SetWhiteBalanceL( static_cast<CCamera::TWhiteBalance>( aVal ) ) )
+ iWhiteBalance = aVal;
+ break;
+ case KMccCamExposure:
+ MCC_USE_CAMERA( SetExposureL( static_cast<CCamera::TExposure>( aVal ) ) )
+ iExposure = aVal;
+ break;
+ default:
+ User::Leave( KErrNotSupported );
+ }
+ __CONTROLLER( "CMccCameraHandler::SetValue, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::GetValue
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::GetValueL( TUint32 /*aParam*/, TReal& /*aVal*/ )
+ {
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::SetValue
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::SetValueL( TUint32 /*aParam*/, TReal /*aVal*/ )
+ {
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ReserveResourcesL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ReserveResourcesL(
+ TInt aCameraIndex, TBool aForceCameraCreation )
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::ReserveResourcesL, forced:",
+ aForceCameraCreation )
+
+ // If camera is in use, camera with different index cannot be reserved
+ if ( iCamera )
+ {
+ __ASSERT_ALWAYS( iCameraIndex == aCameraIndex, User::Leave( KErrInUse ) );
+ }
+ else
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::ReserveResourcesL, creating camera (index):",
+ aCameraIndex )
+ TBool bIndexChanged = (iCameraIndex != aCameraIndex);
+ iCameraIndex = aCameraIndex;
+ iCamera = CreateCameraL();
+ if ( bIndexChanged )
+ {
+ /* Reset the camera handler internal values , for example zoom factor */
+ ResetCameraHandler();
+ }
+ }
+
+ __ASSERT_ALWAYS( iCamera, User::Leave( KErrNotReady ) );
+
+ if ( iState == EFailed )
+ {
+ __CONTROLLER( "CMccCameraHandler::ReserveResourcesL, async failure has occured!" )
+ User::Leave( KErrInUse );
+ }
+ else if ( iState == EInit )
+ {
+ __CONTROLLER( "CMccCameraHandler::ReserveResourcesL, reserving" )
+
+ iCamera->Reserve();
+ iState = EReserving;
+ }
+ else
+ {
+ __CONTROLLER( "CMccCameraHandler::ReserveResourcesL, already reserved" )
+ }
+
+ iForcedResourceReservation = aForceCameraCreation;
+
+ __CONTROLLER( "CMccCameraHandler::ReserveResourcesL, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ReleaseResources
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ReleaseResources()
+ {
+ __CONTROLLER( "CMccCameraHandler::ReleaseResources" )
+
+ if ( iForcedResourceReservation )
+ {
+ __CONTROLLER( "CMccCameraHandler:: forcefully reserved, not releasing" )
+ }
+ else if ( !IsViewFinderEnabled() )
+ {
+ DoReleaseScreen();
+ DoReleaseCamera();
+ }
+ else
+ {
+ // Camera is not really released in case viewfinder is still enabled.
+ __CONTROLLER( "CMccCameraHandler:: Do not release yet, wait for vf disabling" )
+ }
+
+
+ __CONTROLLER( "CMccCameraHandler::ReleaseResources, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::Handle
+// -----------------------------------------------------------------------------
+//
+TUint32 CMccCameraHandler::Handle()
+ {
+ if ( iCamera )
+ {
+ return iCamera->Handle();
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::IsCameraReady
+// -----------------------------------------------------------------------------
+//
+TBool CMccCameraHandler::IsCameraReady()
+ {
+ return ( iState == EPowered );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::MonitorCameraReservation
+// -----------------------------------------------------------------------------
+//
+TInt CMccCameraHandler::MonitorCameraReservation(
+ MMccCameraHandlerObserver& aObserver,
+ TBool aForceCameraReserve )
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::MonitorCameraReservation, force",
+ aForceCameraReserve )
+ TInt err( KErrNone );
+ if ( iState != EPowered )
+ {
+ __CONTROLLER( "CMccCameraHandler::MonitorCameraReservation, start monitoring" )
+ err = iObservers.Append( &aObserver );
+ if ( !err && aForceCameraReserve )
+ {
+
+ TRAP( err, ReserveResourcesL( iCameraIndex, aForceCameraReserve ) );
+ }
+ }
+ else
+ {
+ // Camera is already ready for usage
+ err = KErrArgument;
+ }
+
+ __CONTROLLER_INT1( "CMccCameraHandler::MonitorCameraReservation, exit with err", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::StopCameraMonitoring
+// -----------------------------------------------------------------------------
+//
+TInt CMccCameraHandler::StopCameraMonitoring(
+ MMccCameraHandlerObserver& aObserver,
+ TBool aForceCameraRelease )
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::StopCameraMonitoring, force",
+ aForceCameraRelease )
+ TInt err( KErrNone );
+ TInt index = iObservers.Find( &aObserver );
+ if ( index != KErrNotFound )
+ {
+ iObservers.Remove( index );
+ }
+ else
+ {
+ err = KErrNotFound;
+ }
+
+ if ( iForcedResourceReservation && aForceCameraRelease )
+ {
+ __CONTROLLER( "CMccCameraHandler::StopCameraMonitoring, releasing resource" )
+ iForcedResourceReservation = EFalse;
+ ReleaseResources();
+ }
+
+ __CONTROLLER_INT1( "CMccCameraHandler::StopCameraMonitoring, exit with err", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::HandleEvent
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::HandleEvent( const TECAMEvent& aEvent )
+ {
+ __CONTROLLER( "CMccCameraHandler::HandleEvent" )
+
+ if ( aEvent.iEventType == KUidECamEventReserveComplete )
+ {
+ ReserveComplete( aEvent.iErrorCode );
+ }
+ else if ( aEvent.iEventType == KUidECamEventPowerOnComplete )
+ {
+ PowerOnComplete( aEvent.iErrorCode );
+ }
+ else
+ {
+ __CONTROLLER( "CMccCameraHandler::HandleEvent, unknown event" )
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ViewFinderReady
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ViewFinderReady(
+ MCameraBuffer& aCameraBuffer,
+ TInt aError )
+ {
+ if ( !aError )
+ {
+ if ( aCameraBuffer.NumFrames() > 0 )
+ {
+ TRAP( aError, DoViewFinderFrameReady( aCameraBuffer.BitmapL( 0 ) ) );
+ }
+ else
+ {
+ #if ( defined __WINSCW__ ) || ( defined __WINS__ )
+ // Bitmap might be missing in emulator, ignore the problem
+ __CONTROLLER( "CMccCameraHandler::ViewFinderReady, no bitmap" )
+ #else
+ aError = KErrNotReady;
+ #endif
+ }
+ }
+ if ( aError )
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::ViewFinderReady, error:", aError )
+ iState = EFailed;
+ }
+
+ aCameraBuffer.Release();
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ImageBufferReady
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ImageBufferReady(
+ MCameraBuffer& /*aCameraBuffer*/,TInt /*aError*/ )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::VideoBufferReady
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::VideoBufferReady(
+ MCameraBuffer& /*aCameraBuffer*/,TInt /*aError*/ )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::TimerExpiredL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::TimerExpiredL( TMccTimerId /*aTimerId*/, TAny* /*aTimerParam*/ )
+ {
+ __CONTROLLER( "CMccCameraHandler::TimerExpiredL, NOP" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ReserveComplete
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ReserveComplete( TInt aError )
+ {
+ __CONTROLLER( "CMccCameraHandler::ReserveComplete" )
+ DoReserveComplete( aError );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::PowerOnComplete
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::PowerOnComplete( TInt aError )
+ {
+ __CONTROLLER( "CMccCameraHandler::PowerOnComplete" )
+ DoPowerOnComplete( aError );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ViewFinderFrameReady
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ViewFinderFrameReady( CFbsBitmap& aFrame )
+ {
+ DoViewFinderFrameReady( aFrame );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ImageReady
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ImageReady( CFbsBitmap* /*aBitmap*/, HBufC8* /*aData*/, TInt /*aError*/ )
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::FrameBufferReady
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::FrameBufferReady( MFrameBuffer* /*aFrameBuffer*/, TInt /*aError*/ )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::DoReserveComplete
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::DoReserveComplete( TInt aError )
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::DoReserveComplete, with value", aError )
+ if ( aError == KErrNone )
+ {
+ __CONTROLLER( "CMccCameraHandler::DoReserveComplete, powering on camera" )
+ iState = EReserved;
+ iCamera->PowerOn();
+ }
+ else
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::DoReserveComplete, reserving failed", aError )
+ iState = EFailed;
+
+ // Notify observers immediately since reservation is not continued
+ NotifyObservers( aError );
+ }
+ __CONTROLLER( "CMccCameraHandler::DoReserveComplete, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::DoPowerOnComplete
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::DoPowerOnComplete( TInt aError )
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::DoPowerOnComplete, with value", aError )
+ if ( aError == KErrNone )
+ {
+ iState = EPowered;
+
+ // Viewfinder was enabled before resource release, enable again.
+ // Also set old camera settings.
+ if ( iViewFinderEnabled )
+ {
+ TRAP( aError,
+ {
+ EnableViewFinderL( iViewFinderSettings );
+ UpdateCameraSettingsL();
+ }
+ );
+ if ( aError )
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::DoPowerOnComplete, setting renew failure",
+ aError )
+ iState = EFailed;
+ }
+ }
+ }
+ else
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::DoPowerOnComplete, powering failed", aError )
+ iState = EFailed;
+ }
+
+ // Notify observers about success or failure
+ NotifyObservers( aError );
+
+ __CONTROLLER( "CMccCameraHandler::DoPowerOnComplete, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::DoViewFinderFrameReady
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::DoViewFinderFrameReady( CFbsBitmap& aFrame )
+ {
+ MCC_USE_SCREEN( Draw( aFrame ) )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::NotifyObservers
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::NotifyObservers( TInt aError )
+ {
+ __CONTROLLER_INT1( "CMccCameraHandler::NotifyObservers, error", aError )
+
+ TInt lastIndex( iObservers.Count() - 1 );
+ for ( TInt i = lastIndex; i >= 0; i-- )
+ {
+ iObservers[ i ]->CameraReady( aError );
+ iObservers.Remove( i );
+ }
+
+ __CONTROLLER( "CMccCameraHandler::NotifyObservers, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::SettingsChanged
+// -----------------------------------------------------------------------------
+//
+TBool CMccCameraHandler::SettingsChanged( const TMccVideoSinkSetting& aSetting ) const
+ {
+ return ( iViewFinderSettings.iLocation != aSetting.iLocation ||
+ iViewFinderSettings.iSize != aSetting.iSize ||
+ iViewFinderSettings.iDeviceIndex != aSetting.iDeviceIndex ||
+ iViewFinderSettings.iWindowOrdinalPosition != aSetting.iWindowOrdinalPosition ||
+ iViewFinderSettings.iWindowOrdinalPriority != aSetting.iWindowOrdinalPriority );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::UpdateCameraSettingsL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::UpdateCameraSettingsL()
+ {
+ __CONTROLLER( "CMccCameraHandler::UpdateCameraSettingsL" )
+
+ SetValueL( KMccCamZoomFactor, iZoom );
+ SetValueL( KMccCamDigitZoomFactor, iDigitalZoom );
+ SetValueL( KMccCamContrast, iContrast );
+ SetValueL( KMccCamBrightness, iBrightness );
+ SetValueL( KMccCamWhiteBalance, iWhiteBalance );
+ SetValueL( KMccCamExposure, iExposure );
+
+ __CONTROLLER( "CMccCameraHandler::UpdateCameraSettingsL, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::CreateCameraL
+// -----------------------------------------------------------------------------
+//
+CCamera* CMccCameraHandler::CreateCameraL()
+ {
+ __CONTROLLER( "CMccCameraHandler::CreateCameraL" )
+
+ CCamera* camera = NULL;
+ TRAPD( err, camera = CCamera::New2L( *this, iCameraIndex, iPriority ) );
+ __CONTROLLER_INT1( "CMccCameraHandler::CreateCameraL, camera2 creation, err:", err )
+
+ if ( err == KErrNotSupported )
+ {
+ camera = CCamera::NewL( *this, iCameraIndex );
+ }
+ else
+ {
+ User::LeaveIfError( err );
+ }
+
+ __CONTROLLER( "CMccCameraHandler::CreateCameraL, exit" )
+ return camera;
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::DoReleaseScreen
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::DoReleaseScreen()
+ {
+ __CONTROLLER( "CMccCameraHandler::DoReleaseScreen" );
+
+ delete iScreen;
+ iScreen = NULL;
+
+ __CONTROLLER( "CMccCameraHandler::DoReleaseScreen, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::DoReleaseCamera
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::DoReleaseCamera()
+ {
+ __CONTROLLER( "CMccCameraHandler::DoReleaseCamera" )
+
+ MCC_USE_SCREEN( SetCamera( NULL ) )
+
+ if ( iCamera )
+ {
+ iCamera->Release();
+ }
+
+ delete iCamera;
+ iCamera = NULL;
+
+ iState = EInit;
+
+ __CONTROLLER( "CMccCameraHandler::DoReleaseCamera, exit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::ResetCameraHandler
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::ResetCameraHandler()
+ {
+ __CONTROLLER( "CMccCameraHandler::ResetCameraHandler, entry" )
+ iZoom = KMccCameraHandlerValueNotAssigned;
+ iDigitalZoom = KMccCameraHandlerValueNotAssigned;
+ iContrast = KMccCameraHandlerValueNotAssigned;
+ iBrightness = KMccCameraHandlerValueNotAssigned;
+ iWhiteBalance = KMccCameraHandlerValueNotAssigned;
+ iExposure = KMccCameraHandlerValueNotAssigned;
+ __CONTROLLER( "CMccCameraHandler::ResetCameraHandler, exit" )
+ }
+
+#ifdef MCC_CAMERAHANDLER_TEST
+
+_LIT( KTestCameraPluginName, "C:\\102070cc.txt" );
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::CreateDependencyFileL
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::CreateDependencyFileL()
+ {
+ // Enforce dependency
+ // create the file the plugin depends on.
+ User::LeaveIfError( iFsSession.Connect() );
+ RFile file;
+ TInt err = file.Replace( iFsSession, KTestCameraPluginName, EFileShareAny );
+ file.Close();
+ if ( err != KErrNone )
+ {
+ User::LeaveIfError( KErrNotSupported );
+ }
+ User::LeaveIfError( iFbsSession.Connect( iFsSession ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CMccCameraHandler::RemoveDependencyFile
+// -----------------------------------------------------------------------------
+//
+void CMccCameraHandler::RemoveDependencyFile()
+ {
+ iFbsSession.Disconnect();
+ iFsSession.Delete( KTestCameraPluginName );
+ iFsSession.Close();
+ }
+
+#endif
+
+// End of file
+