1 /*

     2 * Copyright (c) 2009 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:

    15 *

    16 */

    17 #include "cxecameradevicecontrolsymbian.h"

    18 #include "cxesettingsimp.h"

    19 #include "cxefeaturemanagerimp.h"

    20 #include "cxesettingsmodel.h"

    21 #include "cxutils.h"

    22 #include "cxenamespace.h"

    23 #include "cxeerrormappingsymbian.h"

    24 #include "cxestate.h"

    25 

    26 #include "OstTraceDefinitions.h"

    27 #ifdef OST_TRACE_COMPILER_IN_USE

    28 #include "cxecameradevicecontrolsymbianTraces.h"

    29 #endif

    30 

    31 

    32 

    33 CxeCameraDeviceControlSymbian::CxeCameraDeviceControlSymbian()

    34     : CxeStateMachine("CxeCameraDeviceControlSymbian"),

    35     mCameraDevice(NULL),

    36     mCameraIndex(Cxe::PrimaryCameraIndex),

    37     mCameraMode(Cxe::ImageMode)

    38 {

    39     CX_DEBUG_ENTER_FUNCTION();

    40 

    41 #ifdef FORCE_SECONDARY_CAMERA

    42     mCameraIndex = Cxe::SecondaryCameraIndex;

    43 #endif

    44     qRegisterMetaType<CxeCameraDeviceControl::State>();

    45     initializeStates();

    46 

    47     mCameraDevice = new CxeCameraDevice();

    48 

    49     CX_DEBUG_EXIT_FUNCTION();

    50 }

    51 

    52 CxeCameraDeviceControlSymbian::~CxeCameraDeviceControlSymbian()

    53 {

    54     CX_DEBUG_ENTER_FUNCTION();

    55 

    56     // release current camera

    57     releaseCurrentCamera();

    58 

    59     delete mCameraDevice;

    60 

    61     CX_DEBUG_EXIT_FUNCTION();

    62 }

    63 

    64 void CxeCameraDeviceControlSymbian::init()

    65 {

    66     CX_DEBUG_ENTER_FUNCTION();

    67 

    68     CxeError::Id err = mCameraDevice->newCamera(mCameraIndex, this);

    69 

    70     if (err) {

    71         emit initModeComplete(err);

    72     }

    73 

    74     CX_DEBUG_EXIT_FUNCTION();

    75 }

    76 

    77 void CxeCameraDeviceControlSymbian::reserve()

    78 {

    79     CX_DEBUG_ENTER_FUNCTION();

    80 

    81     CX_DEBUG_ASSERT(mCameraDevice && mCameraDevice->camera());

    82 

    83     if (state() == Idle) {

    84         setState(Initializing);

    85         mCameraDevice->camera()->Reserve();

    86         OstTrace0(camerax_performance, CXECAMERADEVICECONTROLSYMBIAN_RESERVE, "msg: e_CX_RESERVE 1");

    87     } else if (state() == PendingRelease) {

    88         // if we get a reserve request and if there is a pending release

    89         // it is just fine to continue the init operation.

    90         setState(Initializing);

    91     } else {

    92         // nothing to do

    93     }

    94 

    95     CX_DEBUG_EXIT_FUNCTION();

    96 }

    97 

    98 void CxeCameraDeviceControlSymbian::powerOn()

    99 {

   100     CX_DEBUG_ENTER_FUNCTION();

   101 

   102     CX_DEBUG_ASSERT(mCameraDevice && mCameraDevice->camera());

   103     if (state() == Initializing) {

   104         mCameraDevice->camera()->PowerOn();

   105         OstTrace0(camerax_performance, CXECAMERADEVICECONTROLSYMBIAN_POWERON, "msg: e_CX_POWER_ON 1");

   106     }

   107     CX_DEBUG_EXIT_FUNCTION();

   108 }

   109 

   110 void CxeCameraDeviceControlSymbian::HandleEvent(const TECAMEvent &aEvent)

   111 {

   112     doHandleEvent( aEvent );

   113     emit cameraEvent( aEvent.iEventType.iUid, aEvent.iErrorCode );

   114 }

   115 

   116 void CxeCameraDeviceControlSymbian::doHandleEvent(const TECAMEvent &aEvent)

   117 {

   118     CX_DEBUG_ENTER_FUNCTION();

   119 

   120     CX_DEBUG(("Cxe: event 0x%08x, %d", aEvent.iEventType.iUid, aEvent.iErrorCode));

   121 

   122     if(aEvent.iEventType == KUidECamEventReserveComplete) {

   123         handleReserveComplete(aEvent.iErrorCode);

   124     }

   125     else if(aEvent.iEventType == KUidECamEventPowerOnComplete) {

   126         handlePowerOnComplete(aEvent.iErrorCode);

   127     }

   128     else if(aEvent.iEventType == KUidECamEventCameraNoLongerReserved)

   129         {

   130         handleNoLongerReserved(aEvent.iErrorCode);

   131         }

   132     else

   133         {

   134         // We don't care about this event -- ignore

   135         }

   136 

   137     CX_DEBUG_EXIT_FUNCTION();

   138 }

   139 

   140 void CxeCameraDeviceControlSymbian::handleReserveComplete(int error)

   141 {

   142     CX_DEBUG_ENTER_FUNCTION();

   143     OstTrace0( camerax_performance, CXECAMERADEVICECONTROLSYMBIAN_HANDLERESERVECOMPLETE, "msg: e_CX_RESERVE 0" );

   144 

   145     if(state() == PendingRelease) {

   146         release();

   147     } else {

   148         if (!error) {

   149             powerOn();

   150         } else {

   151             emit initModeComplete(CxeErrorHandlingSymbian::map(error));

   152             setState(Idle);

   153         }

   154     }

   155 

   156     CX_DEBUG_EXIT_FUNCTION();

   157 }

   158 

   159 void CxeCameraDeviceControlSymbian::handlePowerOnComplete(int error)

   160 {

   161     CX_DEBUG_ENTER_FUNCTION();

   162     OstTrace0(camerax_performance, CXECAMERADEVICECONTROLSYMBIAN_HANDLEPOWERONCOMPLETE, "msg: e_CX_POWER_ON 0");

   163 

   164     if(state() == PendingRelease) {

   165         release();

   166     } else {

   167         if (!error) {

   168             setState(Ready);

   169             emit deviceReady(); // this will trigger prepare for either still or video mode

   170         } else {

   171             setState(PendingRelease);

   172             release();

   173             emit initModeComplete(CxeErrorHandlingSymbian::map(error));

   174         }

   175     }

   176 

   177     CX_DEBUG_EXIT_FUNCTION();

   178 }

   179 

   180 void CxeCameraDeviceControlSymbian::handleNoLongerReserved(int /* error */)

   181 {

   182     setState( Idle );

   183     //! @todo: handle cases where camera is lost

   184 }

   185 

   186 

   187 /*

   188 * switch between camera <-> primary <-> secondary

   189 */

   190 

   191 CxeError::Id CxeCameraDeviceControlSymbian::switchCamera(Cxe::CameraIndex cameraIndex)

   192 {

   193     CX_DEBUG_ENTER_FUNCTION();

   194 

   195 #ifdef FORCE_SECONDARY_CAMERA

   196     // 2nd camera forced use, make us believe camera never needs to be swithed.

   197     CX_DEBUG(("CxeCameraDeviceControlSymbian::switchCamera() second camera forced, skip switch"));

   198     cameraIndex = mCameraIndex;

   199 #endif

   200 

   201     // during mode change, we have to re-create camera reference and release resources.

   202     // in all other cases if the camera indexes are same, it means that camera reference

   203     // is already created and hence we can return immediately.

   204     if (cameraIndex == mCameraIndex) {

   205         CX_DEBUG_EXIT_FUNCTION();

   206         return CxeError::None;

   207     }

   208 

   209     releaseCurrentCamera();

   210 

   211     CxeError::Id err = mCameraDevice->newCamera(cameraIndex, this);

   212 

   213     if (err == CxeError::None){

   214         // CCamera object created, so make sure that appropriate index is used

   215         mCameraIndex = cameraIndex;

   216     }

   217 

   218     if (!err) { // if there is no error creating new camera, then start Reserve

   219         reserve();

   220     }

   221 

   222     CX_DEBUG_EXIT_FUNCTION();

   223     return err;

   224 }

   225 

   226 void CxeCameraDeviceControlSymbian::release()

   227 {

   228     CX_DEBUG_ENTER_FUNCTION();

   229 

   230     if (state() == Idle) {

   231         // nothing to do

   232         return;

   233     }

   234 

   235     if (state() == Initializing) {

   236         setState(PendingRelease);

   237     } else {

   238         mCameraDevice->releaseCamera();

   239         setState(Idle);

   240     }

   241 

   242     CX_DEBUG_EXIT_FUNCTION();

   243 }

   244 

   245 /*

   246 * Release resources w.r.t current camera

   247 */

   248 void CxeCameraDeviceControlSymbian::releaseCurrentCamera()

   249 {

   250     CX_DEBUG_ENTER_FUNCTION();

   251 

   252     release();

   253     // delete old camera instance, this will inturn generates "prepareForCameraDelete" event

   254     // across all interested classes which wants to do cleanup for new camera reference change

   255     mCameraDevice->deleteCamera();

   256 

   257     CX_DEBUG_EXIT_FUNCTION();

   258 }

   259 

   260 void CxeCameraDeviceControlSymbian::ViewFinderReady(MCameraBuffer &aCameraBuffer, TInt aError)

   261 {

   262     CX_DEBUG_ENTER_FUNCTION();

   263     emit vfFrameReady(&aCameraBuffer, aError);

   264     CX_DEBUG_EXIT_FUNCTION();

   265 }

   266 

   267 void CxeCameraDeviceControlSymbian::ImageBufferReady(MCameraBuffer& aCameraBuffer, TInt aError)

   268 {

   269     CX_DEBUG_ENTER_FUNCTION();

   270 

   271     emit imageBufferReady( &aCameraBuffer, aError );

   272 

   273     CX_DEBUG_EXIT_FUNCTION();

   274 }

   275 

   276 void CxeCameraDeviceControlSymbian::VideoBufferReady(MCameraBuffer &/*aCameraBuffer*/, TInt /*aError*/)

   277 {

   278     CX_DEBUG_IN_FUNCTION();

   279 }

   280 

   281 Cxe::CameraIndex CxeCameraDeviceControlSymbian::cameraIndex() const

   282 {

   283     return mCameraIndex;

   284 }

   285 

   286 Cxe::CameraMode CxeCameraDeviceControlSymbian::mode() const

   287 {

   288     return mCameraMode;

   289 }

   290 

   291 void CxeCameraDeviceControlSymbian::setMode(Cxe::CameraMode mode)

   292 {

   293     mCameraMode = mode;

   294 }

   295 

   296 CxeCameraDeviceControl::State CxeCameraDeviceControlSymbian::state() const

   297 {

   298     return static_cast<State>(stateId());

   299 }

   300 

   301 void CxeCameraDeviceControlSymbian::handleStateChanged(int newStateId, CxeError::Id error)

   302 {

   303     emit stateChanged(static_cast<State>(newStateId), error);

   304 }

   305 

   306 void CxeCameraDeviceControlSymbian::initializeStates()

   307 {

   308     // addState( id, name, allowed next states )

   309     addState(new CxeState( Idle , "Idle", Initializing));

   310     addState(new CxeState( Initializing, "Initializing", PendingRelease | Ready | Idle));

   311     addState(new CxeState( Ready, "Ready", Idle));

   312     addState(new CxeState( PendingRelease, "PendingRelease", Initializing | Idle));

   313 

   314     setInitialState(Idle);

   315 }

   316 

   317 CxeCameraDevice *CxeCameraDeviceControlSymbian::cameraDevice()

   318 {

   319     return mCameraDevice;

   320 }

   321 

   322 // end of file