/*

* 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 <QMetaType>

#include <QImage>

#include <fbs.h>

#include <ecam.h> // CCamera

#include <ecam/ecamadvsettingsintf.h> // CCamera

#include <ecamadvsettings.h>

#include "cxesettings.h"

#include "cxeautofocuscontrolsymbian.h"

#include "cxutils.h"

#include "cxecameradevice.h" // CxeCameraDevice

#include "cxesettingsmappersymbian.h"

#include "cxeerrormappingsymbian.h"

#include "cxestate.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxeautofocuscontrolsymbianTraces.h"

#endif

/*

* CxeAutoFocusControlSymbian::CxeAutoFocusControlSymbian

*/

CxeAutoFocusControlSymbian::CxeAutoFocusControlSymbian(CxeCameraDevice &cameraDevice,

                                                       CxeSettings &settings)

    : CxeStateMachine("CxeAutoFocusControlSymbian"),

      mCameraDevice(cameraDevice),

      mAdvancedSettings(NULL),

      mSettings(settings),

      mCancelled(false),

      mFaceTrackingOverride(false)

{

    CX_DEBUG_ENTER_FUNCTION();

    qRegisterMetaType<CxeAutoFocusControl::State>();

    initializeStates();

    OstTrace0(camerax_performance, CXEAUTOFOCUSCONTROLSYMBIAN_CREATE_MID1, "msg: e_CX_ENGINE_CONNECT_SIGNALS 1");

    // connect signals from cameraDevice, so we recieve events when camera reference changes

    QObject::connect( &cameraDevice,

                      SIGNAL(prepareForCameraDelete()),

                      this,SLOT(prepareForCameraDelete()) );

    QObject::connect( &cameraDevice,

                      SIGNAL(cameraAllocated(CxeError::Id)),

                      this,SLOT(handleCameraAllocated(CxeError::Id)) );

    QObject::connect( &cameraDevice,

                      SIGNAL(prepareForRelease()),

                      this,SLOT(prepareForRelease()) );

    // connect scene / setting change callbacks to settings control

    QObject::connect(&mSettings,

            SIGNAL(settingValueChanged(const QString&,QVariant)),

            this,

            SLOT(handleSettingValueChanged(const QString&,QVariant)));

    OstTrace0(camerax_performance, CXEAUTOFOCUSCONTROLSYMBIAN_CREATE_MID2, "msg: e_CX_ENGINE_CONNECT_SIGNALS 0");

    initializeResources();

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* CxeAutoFocusControlSymbian::~CxeAutoFocusControlSymbian

*/

CxeAutoFocusControlSymbian::~CxeAutoFocusControlSymbian()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* Start Autofocus

* \param soundEnabled False if the auto focus sound don't need to be played

* Default value for soundEnabled is true

*/

CxeError::Id CxeAutoFocusControlSymbian::start(bool soundEnabled)

{

    CX_ASSERT_ALWAYS(mAdvancedSettings);

    CX_DEBUG( ("CxeAutoFocusControlSymbian::start() <> state: %d, sound enabled: %d",

               state(), soundEnabled ) );

    mSoundEnabled = soundEnabled;

    CxeError::Id error = CxeError::None;

    if (!isFixedFocusMode(mode())) {

        if ( state() != CxeAutoFocusControl::InProgress && state() != CxeAutoFocusControl::Canceling  ) {

            CX_DEBUG(("CxeAutoFocusControlSymbian::start() calling SetAutoFocusType"));

            mCancelled = false;

            setState(InProgress);

            setFocusRange(mAFRange);

            setFocusType(CCamera::CCameraAdvancedSettings::EAutoFocusTypeSingle);

        } else { // AF was started earlier, can't start until it completes

            error = CxeError::InUse;

        }

    }

    CX_DEBUG( ("CxeAutoFocusControlSymbian::start() <= error: %d", error ) );

    return error;

}

/*

* Cancel Autofocus

*/

void CxeAutoFocusControlSymbian::cancel()

{

    CX_DEBUG( ("CxeAutoFocusControlSymbian::cancel <> state: %d", state() ) );

    CX_DEBUG_ASSERT(mAdvancedSettings);

    if (!mCancelled && !isFixedFocusMode(mode())) {

        if (state() == CxeAutoFocusControl::InProgress) {

            // Need to stop current AF first. Wait for AF event to proceed.

            setState(CxeAutoFocusControl::Canceling);

            setFocusType(CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff);

        } else if (state() != CxeAutoFocusControl::Canceling) {

            // Cancel means move to hyperfocal.

            setState(CxeAutoFocusControl::Canceling);

            CX_DEBUG(("CxeAutoFocusControlSymbian::cancel() moving to hyperfocal"));

            setFocusRange(CCamera::CCameraAdvancedSettings::EFocusRangeHyperfocal);

            setFocusType(CCamera::CCameraAdvancedSettings::EAutoFocusTypeSingle);

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* Set Autofocus mode

*/

void CxeAutoFocusControlSymbian::setMode(CxeAutoFocusControl::Mode newMode)

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG_ASSERT(mAdvancedSettings);

    mAfMode = newMode;

    mAFRange = CxeSettingsMapperSymbian::Map2CameraAutofocus(mAfMode);

    CX_DEBUG(("CxeAutoFocusControlSymbian::setMode() mAFRange: %d", mAFRange));

    mCancelled = false;

    setFocusRange(mAFRange);

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* returns Autofocus mode

*/

CxeAutoFocusControl::Mode CxeAutoFocusControlSymbian::mode() const

{

    return mAfMode;

}

/**

* Is the given mode a fixed focus mode?

*/

bool CxeAutoFocusControlSymbian::isFixedFocusMode(CxeAutoFocusControl::Mode mode) const

{

    return (mode == CxeAutoFocusControl::Hyperfocal

         || mode == CxeAutoFocusControl::Infinity);

}

/*

* To check if Autofocus is supported

*/

bool CxeAutoFocusControlSymbian::supported() const

{

    CX_DEBUG_ENTER_FUNCTION();

    bool supported =

        (supportedFocusTypes() != CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff);

    CX_DEBUG_EXIT_FUNCTION();

    return supported;

}

/*

* Slot for handling ECam events

*/

void CxeAutoFocusControlSymbian::handleCameraEvent(int eventUid, int error)

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG( ("CxeAutoFocusControlSymbian::handleCameraEvent <> state: %d error %d", state(), error ) );

    CX_DEBUG( ("CxeAutoFocusControlSymbian::handleCameraEvent <> uid: %x optimalfocusuid: %x focustype2uid %x",

              eventUid,

              KUidECamEventCameraSettingsOptimalFocusUidValue,

              KUidECamEventCameraSettingAutoFocusType2UidValue ));

    // We're only interested in autofocus events

    if ( eventUid == KUidECamEventCameraSettingsOptimalFocusUidValue ||

         eventUid == KUidECamEventCameraSettingAutoFocusType2UidValue ||

         eventUid == KUidECamEventCameraSettingFocusRangeUidValue) {

         // Autofocus Event handle it.

         handleAfEvent(eventUid, error);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

void CxeAutoFocusControlSymbian::prepareForRelease()

{

    CX_DEBUG_ENTER_FUNCTION();

    // camera is anyway released, so no need to cancel the AF anyway

    setState(CxeAutoFocusControl::Unknown);

    mCancelled = false;

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* camera reference changing, release resources

*/

void CxeAutoFocusControlSymbian::prepareForCameraDelete()

{

    CX_DEBUG_ENTER_FUNCTION();

    prepareForRelease();

    mAdvancedSettings = NULL;

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* new camera available,

*/

void CxeAutoFocusControlSymbian::handleCameraAllocated(CxeError::Id error)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (!error) {

        setState(CxeAutoFocusControl::Unknown);

        mCancelled = false;

        initializeResources();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* CxeAutoFocusControlSymbian::state

*/

CxeAutoFocusControl::State CxeAutoFocusControlSymbian::state() const

{

    return static_cast<State>( stateId() );

}

/*

* CxeAutoFocusControlSymbian::handleStateChanged

*/

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

{

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

}

/*

* CxeAutoFocusControlSymbian::initializeStates

*/

void CxeAutoFocusControlSymbian::initializeStates()

{

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

    addState( new CxeState( Unknown , "Unknown", InProgress | Canceling ) );

    addState( new CxeState( InProgress , "InProgress", Unknown | Failed | Ready | Canceling ) );

    addState( new CxeState( Failed , "Failed", InProgress | Unknown | Canceling ) );

    addState( new CxeState( Ready , "Ready", Unknown | InProgress | Canceling ) );

    addState( new CxeState( Canceling , "Canceling", Unknown ) );

    setInitialState( Unknown );

}

/*

* CxeAutoFocusControlSymbian::initializeResources

*/

void CxeAutoFocusControlSymbian::initializeResources()

{

    CX_DEBUG_ENTER_FUNCTION();

    // No check if non-null. Not supported if zero pointer (see supported() ).

    mAdvancedSettings = mCameraDevice.advancedSettings();

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* CxeAutoFocusControlSymbian::setFocusRange

*/

void CxeAutoFocusControlSymbian::setFocusRange(CCamera::CCameraAdvancedSettings::TFocusRange range)

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG_ASSERT(mAdvancedSettings);

    mAdvancedSettings->SetFocusRange(range);

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* CxeAutoFocusControlSymbian::focusRange

*/

CCamera::CCameraAdvancedSettings::TFocusRange CxeAutoFocusControlSymbian::focusRange() const

{

    CX_DEBUG_ENTER_FUNCTION();

    const CCamera::CCameraAdvancedSettings::TFocusRange range(

        mAdvancedSettings

              ? mAdvancedSettings->FocusRange()

              : CCamera::CCameraAdvancedSettings::EFocusRangeAuto );

    CX_DEBUG_EXIT_FUNCTION();

    return range;

}

/*

* CxeAutoFocusControlSymbian::setFocusType

*/

void CxeAutoFocusControlSymbian::setFocusType(CCamera::CCameraAdvancedSettings::TAutoFocusType type)

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG_ASSERT(mAdvancedSettings);

    mAdvancedSettings->SetAutoFocusType(type);

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* CxeAutoFocusControlSymbian::supportedFocusTypes

*/

int CxeAutoFocusControlSymbian::supportedFocusTypes() const

{

    CX_DEBUG_ENTER_FUNCTION();

    const int support( mAdvancedSettings

                     ? mAdvancedSettings->SupportedAutoFocusTypes()

                     : CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff );

    CX_DEBUG_EXIT_FUNCTION();

    return support;

}

/*

* CxeAutoFocusControlSymbian::focusType

*/

CCamera::CCameraAdvancedSettings::TAutoFocusType CxeAutoFocusControlSymbian::focusType() const

{

    CX_DEBUG_ENTER_FUNCTION();

    const CCamera::CCameraAdvancedSettings::TAutoFocusType type(

        mAdvancedSettings

              ? mAdvancedSettings->AutoFocusType()

              : CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff );

    CX_DEBUG_EXIT_FUNCTION();

    return type;

}

/*

* Image Scene mode changed, get the new autofocus value

*/

{

    CX_DEBUG_ENTER_FUNCTION();

    // whenever scene mode is changed we set the state to unknown

    setState(CxeAutoFocusControl::Unknown);

    // we are interested only in the AF range.

    if(scene.contains(CxeSettingIds::FOCAL_RANGE) && supported() ) {

        setMode(static_cast<CxeAutoFocusControl::Mode>(scene[CxeSettingIds::FOCAL_RANGE].toInt()));

        if (isFixedFocusMode(mode())) {

            // Focus now if a fixed focus mode is used.

            setFocusType(CCamera::CCameraAdvancedSettings::EAutoFocusTypeSingle);

            // Set state to InProgress, so we know to set it ready in ECAM callback.

            setState(CxeAutoFocusControl::InProgress);

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*

* CxeAutoFocusControlSymbian::handleAfEvent

*/

void CxeAutoFocusControlSymbian::handleAfEvent(int eventUid, int error)

{

    CX_DEBUG_ENTER_FUNCTION();

    switch ( state() ) {

    case CxeAutoFocusControl::InProgress: {

        if (eventUid == KUidECamEventCameraSettingsOptimalFocusUidValue ) {

            OstTrace0(camerax_performance, CXEAUTOFOCUSCONTROLSYMBIAN_AF_LOCK, "msg: e_CX_AUTOFOCUS_LOCK 0");

            CX_DEBUG(("CxeAutoFocusControlSymbian::handleAfEvent <> KUidECamEventCameraSettingsOptimalFocus"));

            if (KErrNone == error) {

                setState(CxeAutoFocusControl::Ready);

            } else {

            }

         } else if (eventUid == KUidECamEventCameraSettingFocusRangeUidValue) {

             // check for error, we don't need this event for anything else

             if (error != KErrNone) {

                 CX_DEBUG(("CxeAutofocusControlSymbian::handleAfEvent <> "

                         "KUidECamEventCameraSettingFocusRangeUidValue: autofocus failed %d", error));

             }

         }

         break;

        }

    case CxeAutoFocusControl::Canceling: {

        CX_DEBUG(("CxeAutoFocusControlSymbian::handleAfEvent <> Canceling"));

        // Cancelling started by setting AF off to stop ongoing focus operation.

        // Finalize cancelling by setting lens to hyperfocal position.

        if (eventUid == KUidECamEventCameraSettingAutoFocusType2UidValue) {

            if (focusType() == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff) {

                setFocusRange(CCamera::CCameraAdvancedSettings::EFocusRangeHyperfocal);

                setFocusType(CCamera::CCameraAdvancedSettings::EAutoFocusTypeSingle);

            }

        } else if (eventUid == KUidECamEventCameraSettingsOptimalFocusUidValue) {

            mCancelled = true;

            setState(CxeAutoFocusControl::Unknown);

        }

        break;

    }

    default:

        break;

    } // end switch

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

  * Public method for checking if auto focus sound is enabled

  * \return true if enabled

  */

bool CxeAutoFocusControlSymbian::isSoundEnabled() const

{

    return mSoundEnabled;

}

/*!

* Handle new setting value.

* New value is set to camera.

* \param settingId The id of the updated setting

* \param newValue A new value for the updated setting

*/

void CxeAutoFocusControlSymbian::handleSettingValueChanged(const QString& settingId, QVariant newValue)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (settingId == CxeSettingIds::FACE_TRACKING) {

        // Updating AF mode when face tracking is activated

        // in scene mode which doesn't support face tracking

        if (newValue.toInt()) {

            //Face tracking enabled

            if(mAfMode == CxeAutoFocusControl::Infinity ||

               mAfMode == CxeAutoFocusControl::Hyperfocal) {

                mPreviousAFMode = mAfMode;

                setMode(CxeAutoFocusControl::Auto);

                mFaceTrackingOverride = true;

            }

        } else {

            //Face tracking disabled

            if (mFaceTrackingOverride) {

                mAfMode = mPreviousAFMode;

                setMode(mAfMode);

                mFaceTrackingOverride = false;

            }

        }