/*

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

#include <exception>

#include <QPixmap>

#include <coemain.h>

#include <ECamOrientationCustomInterface2.h>

#include <ecamfacetrackingcustomapi.h>

#include <ecamusecasehintcustomapi.h>

#include "cxestillcapturecontrolsymbian.h"

#include "cxeimagedataqueuesymbian.h"

#include "cxefilenamegenerator.h"

#include "cxefilesavethread.h"

#include "cxutils.h"

#include "cxecameradevicecontrol.h"

#include "cxecameradevice.h"

#include "cxesoundplayersymbian.h"

#include "cxestillimagesymbian.h"

#include "cxeviewfindercontrolsymbian.h"

#include "cxesnapshotcontrol.h"

#include "cxesettingsmappersymbian.h"

#include "cxestate.h"

#include "cxesettings.h"

#include "cxeerrormappingsymbian.h"

#include "cxeautofocuscontrol.h"

#include "cxesensoreventhandler.h"

#include "cxesensoreventhandler.h"

#include "cxequalitypresetssymbian.h"

#include "cxediskmonitor.h"

#include "cxeexception.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxestillcapturecontrolsymbianTraces.h"

#endif

// constants

namespace

{

    const TInt64 KMinRequiredSpaceImage = 2000000;

}

/*!

 * Constructor.

 */

CxeStillCaptureControlSymbian::CxeStillCaptureControlSymbian(

    CxeCameraDevice &cameraDevice,

    CxeViewfinderControl &viewfinderControl,

    CxeSnapshotControl &snapshotControl,

    CxeCameraDeviceControl &cameraDeviceControl,

    CxeFilenameGenerator &nameGenerator,

    CxeSensorEventHandler &sensorEventHandler,

    CxeAutoFocusControl &autoFocusControl,

    CxeSettings &settings,

    CxeQualityPresets &qualityPresets,

    CxeFileSaveThread &fileSaveThread,

    CxeDiskMonitor &diskMonitor)

    : CxeStateMachine("CxeStillCaptureControlSymbian"),

      mCameraDevice(cameraDevice),

      mViewfinderControl(viewfinderControl),

      mSnapshotControl(snapshotControl),

      mCameraDeviceControl(cameraDeviceControl),

      mFilenameGenerator(nameGenerator),

      mSensorEventHandler(sensorEventHandler),

      mAutoFocusControl(autoFocusControl),

      mSettings(settings),

      mQualityPresets(qualityPresets),

      mFileSaveThread(fileSaveThread),

      mDiskMonitor(diskMonitor),

      mMode(SingleImageCapture),

      mAfState(CxeAutoFocusControl::Unknown)

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0(camerax_performance, CXESTILLCAPTURECONTROLSYMBIAN_CREATE_IN, "msg: e_CX_STILLCAPTURECONTROL_NEW 1");

    qRegisterMetaType<CxeStillCaptureControl::State>();

    initializeStates();

    reset();

    // If camera is already allocated, call the slot ourselves.

    if (mCameraDevice.camera()) {

        handleCameraAllocated(CxeError::None);

    }

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

    // connect signals from cameraDevice to recieve events when camera reference changes

    connect(&cameraDevice, SIGNAL(prepareForCameraDelete()),

            this, SLOT(prepareForCameraDelete()));

    connect(&cameraDevice, SIGNAL(prepareForRelease()),

            this, SLOT(prepareForRelease()));

    connect(&cameraDevice, SIGNAL(cameraAllocated(CxeError::Id)),

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

    connect(&mSensorEventHandler,

            SIGNAL(sensorEvent(CxeSensorEventHandler::SensorType,QVariant)),

            this, SLOT(handleSensorEvent(CxeSensorEventHandler::SensorType,QVariant)));

    // enabling setting change callbacks to stillcapturecontrol

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

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

    // Connect ECam image buffer ready event

    connect(&mCameraDeviceControl, SIGNAL(imageBufferReady(MCameraBuffer*,int)),

            this, SLOT(handleImageData(MCameraBuffer*,int)));

    // connect snapshot ready signal

    connect(&mSnapshotControl, SIGNAL(snapshotReady(CxeError::Id, const QImage&)),

            this, SLOT(handleSnapshotReady(CxeError::Id, const QImage&)));

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

    mImageDataQueue = new CxeImageDataQueueSymbian();

    mAutoFocusSoundPlayer = new CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::AutoFocus, mSettings);

    mCaptureSoundPlayer = new CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::StillCapture, mSettings);

    OstTrace0(camerax_performance, CXESTILLCAPTURECONTROLSYMBIAN_CREATE_OUT, "msg: e_CX_STILLCAPTURECONTROL_NEW 0");

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Destructor.

 */

CxeStillCaptureControlSymbian::~CxeStillCaptureControlSymbian()

{

    CX_DEBUG_ENTER_FUNCTION();

    deinit();

    reset();

    mIcmSupportedImageResolutions.clear();

    mECamSupportedImageResolutions.clear();

    delete mImageDataQueue;

    delete mCaptureSoundPlayer;

    delete mAutoFocusSoundPlayer;

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Return the current state.

 */

CxeStillCaptureControl::State CxeStillCaptureControlSymbian::state() const

{

    return static_cast<CxeStillCaptureControl::State>( stateId() );

}

/*!

 * Handle state changed event. Normally just emits the signal

 * for observers to react appropriately.

 */

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

{

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

}

/*!

 * Initialize the control states.

 */

void CxeStillCaptureControlSymbian::initializeStates()

{

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

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

    addState(new CxeState( Ready , "Ready", Uninitialized | Capturing));

    addState(new CxeState( Capturing , "Capturing", Uninitialized | Ready));

    setInitialState(Uninitialized);

}

/*!

 * Initialize the still image capture control.

 */

void CxeStillCaptureControlSymbian::init()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0(camerax_performance, CXESTILLCAPTURECONTROLSYMBIAN_INIT_IN, "msg: e_CX_STILL_CAPCONT_INIT 1");

    if (state() == Uninitialized) {

        prepare();

        // Initialize orientation sensor and other sensors

        mSensorEventHandler.init();

    }

    OstTrace0(camerax_performance, CXESTILLCAPTURECONTROLSYMBIAN_INIT_OUT, "msg: e_CX_STILL_CAPCONT_INIT 0");

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Un-initialize the image mode.

 */

void CxeStillCaptureControlSymbian::deinit()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state() == Uninitialized) {

        // nothing to do

        return;

    }

    OstTrace0( camerax_performance, CXESTILLCAPTURECONTROLSYMBIAN_DEINIT_IN, "msg: e_CX_STILLCAPCONT_DEINIT 1" );

    // Stop monitoring disk space.

    mDiskMonitor.stop();

    disconnect(&mDiskMonitor, SIGNAL(diskSpaceChanged()), this, SLOT(handleDiskSpaceChanged()));

    //stop viewfinder

    mViewfinderControl.stop();

    if (state() == Capturing) {

        mCameraDevice.camera()->CancelCaptureImage();

    }

    // disable sensor event handler.

    mSensorEventHandler.deinit();

    mSnapshotControl.stop();

    setState(Uninitialized);

    OstTrace0( camerax_performance, CXESTILLCAPTURECONTROLSYMBIAN_DEINIT_OUT, "msg: e_CX_STILLCAPCONT_DEINIT 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Prepare still capture mode.

 */

void CxeStillCaptureControlSymbian::prepare()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state() != Uninitialized) {

        // wrong state and we return

        return;

    }

    OstTrace0(camerax_performance, CXESTILLCAPTURECONTROL_PREPARE_IN, "msg: e_CX_STILLCAPCONT_PREPARE 1");

    CxeError::Id status(CxeError::None);

    try {

        // Update capture parameters

        updateStillCaptureParameters();

        // Prepare Image capture

        CX_DEBUG(("Calling PrepareImageCaptureL, resolution index = %d", mSizeIndex));

        OstTrace0(camerax_performance, CXESTILLCAPTURECONTROL_PREPARE_MID1, "msg: e_CX_PREPARE_IMAGE_CAPTURE 1");

        QT_TRAP_THROWING(mCameraDevice.camera()->PrepareImageCaptureL(mCaptureFormat, mSizeIndex));

        OstTrace0(camerax_performance, CXESTILLCAPTURECONTROL_PREPARE_MID2, "msg: e_CX_PREPARE_IMAGE_CAPTURE 0");

        // Start viewfinder before claiming to be ready,

        // as e.g. pending capture might be started by state change,

        // and viewfinder start might have problems with just started capturing.

        // If viewfinder is already running, this call does nothing.

        mViewfinderControl.start();

        // Prepare snapshot

        prepareSnapshot();

        // Start monitoring disk space.

        mDiskMonitor.start();

        connect(&mDiskMonitor, SIGNAL(diskSpaceChanged()), this, SLOT(handleDiskSpaceChanged()));

        // Enable AF reticule drawing by adaptation

        MCameraFaceTracking *faceTracking = mCameraDevice.faceTracking();

        if (faceTracking) {

            TRAP_IGNORE(faceTracking->EnableFaceIndicatorsL(ETrue));

        }

        // Still capture and still snapshot are OK.

        // We can safely set state to READY.

        setState(Ready);

        // inform zoom control to prepare zoom

        emit prepareZoomForStill(mSizeIndex);

    } catch (const std::exception &e) {

        // Exception encountered, free resources.

        CX_DEBUG(("Image Prepare FAILED! symbian error = %d", qt_symbian_exception2Error(e)));

        status = CxeErrorHandlingSymbian::map(qt_symbian_exception2Error(e));

        deinit();

    }

    // Inform interested parties that image mode has been prepared for capture

    emit imagePrepareComplete(status);

    OstTrace0(camerax_performance, CXESTILLCAPTURECONTROL_GOTOSTILL, "msg: e_CX_GO_TO_STILL_MODE 0");

    OstTrace0(camerax_performance, CXESTILLCAPTURECONTROL_PREPARE_OUT, "msg: e_CX_STILLCAPCONT_PREPARE 0");

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 Prepare still snapshot

 Throws exception on error.

 */

void CxeStillCaptureControlSymbian::prepareSnapshot()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXESTILLCAPTURECONTROL_PREPARESNAP_1, "msg: e_CX_PREPARE_SNAPSHOT 1" );

    QSize snapshotSize = mSnapshotControl.calculateSnapshotSize(

                            mViewfinderControl.deviceDisplayResolution(),

                            mCurrentImageDetails.mAspectRatio);

    mSnapshotControl.start(snapshotSize);

    OstTrace0( camerax_performance, CXESTILLCAPTURECONTROL_PREPARESNAP_2, "msg: e_CX_PREPARE_SNAPSHOT 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

    Update image capture parameters. mCurrentImageDetails, mCaptureFormat and

    mSizeIndex are updated based on the current settings.

*/

void CxeStillCaptureControlSymbian::updateStillCaptureParameters()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXESTILLCAPTURECONTROL_UPDATESTILLCAPTUREPARAMETERS_1, "msg: e_CX_UPDATE_STILL_CAPTURE_PARAMETERS 1" );

    int imageQuality = 0;

    CxeError::Id err = CxeError::None;

    if (mCameraDeviceControl.cameraIndex() == Cxe::PrimaryCameraIndex) {

        try {

            imageQuality = mSettings.get<int>(CxeSettingIds::IMAGE_QUALITY);

            bool validQuality = (imageQuality >= 0 &&

                                 imageQuality < mIcmSupportedImageResolutions.count());

            if (validQuality ) {

                // get image quality details

                mCurrentImageDetails = mIcmSupportedImageResolutions.at(imageQuality);

            } else {

                err = CxeError::NotFound;

                CX_DEBUG(("Invalid ImageQuality = %d", imageQuality));

            }

        } catch (CxeException &e) {

            err = (CxeError::Id) e.error();

        }

    } else {

        // we are in secondary camera

        // get secondary camera image quality details

       mCurrentImageDetails = mIcmSupportedImageResolutions.at(imageQuality);

    }

    mSizeIndex = 0;

    if (err == CxeError::None) {

        int imageWidth = mCurrentImageDetails.mWidth;

        int imageHeight = mCurrentImageDetails.mHeight;

        CX_DEBUG(("CxeStillCaptureControlSymbian::updateStillCaptureParameters <> resolution = (%d, %d)", imageWidth, imageHeight));

        TSize imageSize;

        imageSize.SetSize(imageWidth, imageHeight);

        if (mECamSupportedImageResolutions.count() > 0) {

            mSizeIndex = mECamSupportedImageResolutions.indexOf(imageSize);

        }

        if (mSizeIndex < 0) {

            CX_DEBUG(("CxeStillCaptureControlSymbian::updateStillCaptureParameters - WARNING! resolution not supported, falling back to index 0"));

            mSizeIndex = 0;

        }

        mCaptureFormat = supportedStillFormat(mCameraDeviceControl.cameraIndex());

    }

    OstTrace0( camerax_performance, CXESTILLCAPTURECONTROL_UPDATESTILLCAPTUREPARAMETERS_2, "msg: e_CX_UPDATE_STILL_CAPTURE_PARAMETERS 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

 * Command to start image capture now.

 * @sa handleCameraEvent

 */

void CxeStillCaptureControlSymbian::capture()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mCameraDevice.camera());

    // Start the image capture as fast as possible to minimize lag.

    // Check e.g. space available *after* this.

    // Capture sound will be played when we receive "image capture event" from ECAM.

    mCameraDevice.camera()->CaptureImage();

    if (imagesLeft() > 0) {

        setState(Capturing);

        //! @todo: NOTE: This call may not stay here. It can move depending on the implementation for burst capture.

        if (mMode == BurstCapture) {

            // Start a new filename sequence

            mFilenameGenerator.startNewImageFilenameSequence();

        }

    } else {

        // There's no space for the image.

        // Cancel started capturing.

        mCameraDevice.camera()->CancelCaptureImage();

        // Report error.

        // Ui notification has anyway some delays, hence handling VF after this.

        emit imageCaptured(CxeError::DiskFull, CxeStillImage::INVALID_ID);

        // Capturing stops viewfinder, so restart it now.

        mViewfinderControl.stop();

        mViewfinderControl.start();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

@Param cameraIndex indicates which camera we are in use, primary/secondary

Returns the format we use for specific camera index.

*/

CCamera::TFormat CxeStillCaptureControlSymbian::supportedStillFormat(Cxe::CameraIndex cameraIndex)

{

    CX_DEBUG_ENTER_FUNCTION();

    Q_UNUSED(cameraIndex);

    // The same image format used for both primary and secodary cameras

    CCamera::TFormat imgFormat = CCamera::EFormatExif;

    CX_DEBUG_EXIT_FUNCTION();

    return imgFormat;

}

/*!

 * Snapshot ready notification. Ask the snapshot from snapshot interface.

 * NB: Typically snapshot arrives before image data but can be in reverse

 * order as well.

 *

 * @param status Status of snapshot creation. CxeError::None if no error, otherwise contains the error code.

 * @param snapshot Snapshot as QImage

 */

void CxeStillCaptureControlSymbian::handleSnapshotReady(CxeError::Id status, const QImage &snapshot)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mCameraDeviceControl.mode() == Cxe::ImageMode) {

        OstTrace0(camerax_performance, CXESTILLCAPTURECONTROL_HANDLESNAPSHOT_1, "msg: e_CX_HANDLE_SNAPSHOT 1");

        QPixmap ss = QPixmap::fromImage(snapshot);

        // Get image container for current snapshot index.

        // Remember to increment counter.

        CxeStillImageSymbian* stillImage = getImageForIndex(mNextSnapshotIndex++);

        if (status == CxeError::None) {

            stillImage->setSnapshot(ss);

        }

        // Emit snapshotReady signal in all cases (error or not)

        emit snapshotReady(status, snapshot, stillImage->id());

        // When the snapshot ready event is handled, prepare new filename.

        if (stillImage->filename().isEmpty()) {

            // Error ignored at this point, try again when image data arrives.

            prepareFilename(stillImage);

        }

        OstTrace0(camerax_performance, CXESTILLCAPTURECONTROL_HANDLESNAPSHOT_2, "msg: e_CX_HANDLE_SNAPSHOT 0");

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Handle ECAM events.

* Needed only for capture sound synchronization.

* @param eventUid ECAM event id.

* @param error Error code. KErrNone if operation has been successful.

*/

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

{

    if (eventUid == KUidECamEventImageCaptureEventUidValue && error == KErrNone) {

        CX_DEBUG(("CxeStillCaptureControlSymbian::handleCameraEvent - image capture event"));

        if (state() == CxeStillCaptureControl::Capturing) {

            mCaptureSoundPlayer->play();

        }

    }

}

/*!

 * handleImageData: Image data received from ECam

 */

void CxeStillCaptureControlSymbian::handleImageData(MCameraBuffer* cameraBuffer, int error)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (state() == CxeStillCaptureControl::Uninitialized) {

        // we ignore this event, when we are not active

        cameraBuffer->Release();

        return;

    }

    // Get image container for current image data index.

    // Remember to increment counter.

    CxeStillImageSymbian* stillImage = getImageForIndex(mNextImageDataIndex++);

    if (error) {

        // Indicate error in image capture to the UI.

        cameraBuffer->Release();

        emit imageCaptured(CxeErrorHandlingSymbian::map(error), stillImage->id());

        return;

    }

    // If filename is not available at this stage, then generate one now

    if (stillImage->filename().isEmpty()) {

        CxeError::Id cxErr = prepareFilename(stillImage);

        if (cxErr) {

            cameraBuffer->Release();

            emit imageCaptured(cxErr, stillImage->id());

            return;