/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "cxecameradevicecontrolsymbian.h"

#include "cxesettingsimp.h"

#include "cxefeaturemanagerimp.h"

#include "cxutils.h"

#include "cxenamespace.h"

#include "cxeerrormappingsymbian.h"

#include "cxestate.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxecameradevicecontrolsymbianTraces.h"

#endif

CxeCameraDeviceControlSymbian::CxeCameraDeviceControlSymbian()

    : CxeStateMachine("CxeCameraDeviceControlSymbian"),

    mCameraDevice(NULL),

    mCameraIndex(Cxe::PrimaryCameraIndex),

    mCameraMode(Cxe::ImageMode)

{

    CX_DEBUG_ENTER_FUNCTION();

#ifdef FORCE_SECONDARY_CAMERA

    mCameraIndex = Cxe::SecondaryCameraIndex;

#endif

    qRegisterMetaType<CxeCameraDeviceControl::State>();

    initializeStates();

    mCameraDevice = new CxeCameraDevice();

    //!@todo Temporary delay before reserving camera to avoid timing issues

    connect(&mReserveTimer, SIGNAL(timeout()), this, SLOT(doReserve()));

    mReserveTimer.setSingleShot(true);

    CX_DEBUG_EXIT_FUNCTION();

}

CxeCameraDeviceControlSymbian::~CxeCameraDeviceControlSymbian()

{

    CX_DEBUG_ENTER_FUNCTION();

    // release current camera

    releaseCurrentCamera();

    delete mCameraDevice;

    CX_DEBUG_EXIT_FUNCTION();

}

void CxeCameraDeviceControlSymbian::init()

{

    CX_DEBUG_ENTER_FUNCTION();

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

    if (err) {

        emit initModeComplete(err);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

void CxeCameraDeviceControlSymbian::reserve()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mCameraDevice);

    if (state() == Idle) {

        setState(Initializing);

        //!@todo Temporary delay before reserving camera to avoid timing issues

        mReserveTimer.start(2000);

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

        CX_DEBUG(("HACK: Waiting for 2000ms before really doing reserve()"));

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

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

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

        setState(Initializing);

    } else {

        // nothing to do

    }

    CX_DEBUG_EXIT_FUNCTION();

}

void CxeCameraDeviceControlSymbian::doReserve()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mCameraDevice);

    mCameraDevice->reserveCamera();

    CX_DEBUG_EXIT_FUNCTION();

}

void CxeCameraDeviceControlSymbian::powerOn()

{

    CX_DEBUG_ENTER_FUNCTION();

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

    if (state() == Initializing) {

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

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

    }

    CX_DEBUG_EXIT_FUNCTION();

}

void CxeCameraDeviceControlSymbian::HandleEvent(const TECAMEvent &aEvent)

{

    doHandleEvent( aEvent );

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

}

void CxeCameraDeviceControlSymbian::doHandleEvent(const TECAMEvent &aEvent)

{

    CX_DEBUG_ENTER_FUNCTION();

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

    if(aEvent.iEventType == KUidECamEventReserveComplete) {

        handleReserveComplete(aEvent.iErrorCode);

    }

    else if(aEvent.iEventType == KUidECamEventPowerOnComplete) {

        handlePowerOnComplete(aEvent.iErrorCode);

    }

    else if(aEvent.iEventType == KUidECamEventCameraNoLongerReserved)

        {

        handleNoLongerReserved(aEvent.iErrorCode);

        }

    else

        {

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

        }

    CX_DEBUG_EXIT_FUNCTION();

}

void CxeCameraDeviceControlSymbian::handleReserveComplete(int error)

{

    CX_DEBUG_ENTER_FUNCTION();

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

    if(state() == PendingRelease) {

        release();

    } else {

        if (!error) {

            powerOn();

        } else {

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

            setState(Idle);

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

void CxeCameraDeviceControlSymbian::handlePowerOnComplete(int error)

{

    CX_DEBUG_ENTER_FUNCTION();

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

    if(state() == PendingRelease) {

        release();

    } else {

        if (!error) {

            setState(Ready);

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

        } else {

            setState(PendingRelease);

            release();

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

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

{

    setState( Idle );

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

}

/*

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

*/

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

{

    CX_DEBUG_ENTER_FUNCTION();

#ifdef FORCE_SECONDARY_CAMERA

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

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

    cameraIndex = mCameraIndex;

#endif

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

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

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

    if (cameraIndex == mCameraIndex) {

        CX_DEBUG_EXIT_FUNCTION();

        return CxeError::None;

    }

    releaseCurrentCamera();

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

    if (err == CxeError::None){

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

        mCameraIndex = cameraIndex;

    }

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

        reserve();

    }

    CX_DEBUG_EXIT_FUNCTION();

    return err;

}

void CxeCameraDeviceControlSymbian::release()

{

    CX_DEBUG_ENTER_FUNCTION();

    //!@todo Temporary delay before reserving camera to avoid timing issues

    if (mReserveTimer.isActive()) {

        // release() was called when the timer was active

        mReserveTimer.stop();

        mCameraDevice->releaseCamera();

        setState(Idle);

        CX_DEBUG_EXIT_FUNCTION();

        return;

    }

    if (state() == Idle) {

        // nothing to do

        return;

    }

    if (state() == Initializing) {

        setState(PendingRelease);

    } else {

        mCameraDevice->releaseCamera();

        setState(Idle);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* Release resources w.r.t current camera

*/

void CxeCameraDeviceControlSymbian::releaseCurrentCamera()

{

    CX_DEBUG_ENTER_FUNCTION();

    release();

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

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

    mCameraDevice->deleteCamera();

    CX_DEBUG_EXIT_FUNCTION();

}

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

{

    CX_DEBUG_ENTER_FUNCTION();

    emit vfFrameReady(&aCameraBuffer, aError);

    CX_DEBUG_EXIT_FUNCTION();

}

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

{

    CX_DEBUG_ENTER_FUNCTION();

    emit imageBufferReady( &aCameraBuffer, aError );

    CX_DEBUG_EXIT_FUNCTION();

}

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

{

    CX_DEBUG_IN_FUNCTION();

}

Cxe::CameraIndex CxeCameraDeviceControlSymbian::cameraIndex() const

{

    return mCameraIndex;

}

Cxe::CameraMode CxeCameraDeviceControlSymbian::mode() const

{

    return mCameraMode;

}

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

{

    mCameraMode = mode;

}

CxeCameraDeviceControl::State CxeCameraDeviceControlSymbian::state() const

{

    return static_cast<State>(stateId());

}

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

{

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

}

void CxeCameraDeviceControlSymbian::initializeStates()

{

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

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

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

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

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

    setInitialState(Idle);

}

CxeCameraDevice *CxeCameraDeviceControlSymbian::cameraDevice()

{

    return mCameraDevice;

}

// end of file