/*

* Copyright (c) 2009 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 "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 "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 "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxestillcapturecontrolsymbianTraces.h"

#endif

// constants

/**

 * Constructor.

 */

CxeStillCaptureControlSymbian::CxeStillCaptureControlSymbian(

    CxeCameraDevice &cameraDevice,

    CxeViewfinderControl &viewfinderControl,

    CxeCameraDeviceControl &cameraDeviceControl,

    CxeFilenameGenerator &nameGenerator,

    CxeSensorEventHandler &sensorEventHandler,

    CxeAutoFocusControl &autoFocusControl,

    CxeSettings &settings,

    CxeQualityPresets &qualityPresets,

    CxeFileSaveThread &fileSaveThread,

    CxeDiskMonitor &diskMonitor)

    : CxeStateMachine("CxeStillCaptureControlSymbian"),

      mCameraDevice(cameraDevice),

      mViewfinderControl(viewfinderControl),

      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)));

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

    mImageDataQueue = new CxeImageDataQueueSymbian();

    mAutoFocusSoundPlayer = new CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::AutoFocus);

    mCaptureSoundPlayer = new CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::StillCapture);

    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_STILL_CAPCONT_DEINIT 1" );

    // Stop monitoring disk space.

    mDiskMonitor.stop();

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

    //stop viewfinder

    mViewfinderControl.stop();

    // disable sensor event handler.

    mSensorEventHandler.deinit();

    setState(Uninitialized);

    OstTrace0( camerax_performance, CXESTILLCAPTURECONTROLSYMBIAN_DEINIT_OUT, "msg: e_CX_STILL_CAPCONT_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, CXESTILLCAPTURECONTROLSYMBIAN_PREPARE_IN, "msg: e_CX_STILLCAPCONT_PREPARE 1" );

    int err = KErrNone;

    CxeError::Id cxErr = getImageQualityDetails(mCurrentImageDetails);

    int ecamStillResolutionIndex = 0;

    if (cxErr == CxeError::None) {

        int imageWidth =  mCurrentImageDetails.mWidth;

        int imageHeight = mCurrentImageDetails.mHeight;

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

        TSize imageSize;

        imageSize.SetSize(imageWidth, imageHeight);

        if (mECamSupportedImageResolutions.count() > 0) {

            ecamStillResolutionIndex = mECamSupportedImageResolutions.indexOf(imageSize);

        }

        if (ecamStillResolutionIndex < 0) {

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

            ecamStillResolutionIndex = 0;

        }

        // Prepare Image capture

        CCamera::TFormat imgFormat = supportedStillFormat(mCameraDeviceControl.cameraIndex());

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

        TRAP(err, mCameraDevice.camera()->PrepareImageCaptureL(imgFormat, ecamStillResolutionIndex));

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

        CX_DEBUG(("PrepareImageCaptureL done, err=%d, resolution index = %d", err, ecamStillResolutionIndex));

        if (!err) {

            // still capture prepare went fine, try preparing snapshot

            err = prepareStillSnapshot();

        }

    } else {

        err = KErrNotFound;

    }

    if (!err) {

        // 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();

        // 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(ecamStillResolutionIndex);

    } else {

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

        // release resources

        deinit();

    }

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

    emit imagePrepareComplete(CxeErrorHandlingSymbian::map(err));

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

    CX_DEBUG_EXIT_FUNCTION();

}

/**!

 Prepare still snapshot

 Returns symbian error code.

 */

int CxeStillCaptureControlSymbian::prepareStillSnapshot()

{

    CX_DEBUG_ENTER_FUNCTION();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/**!

 imageInfo contains image qualities details

 Returns CxeError error code.

 */

CxeError::Id CxeStillCaptureControlSymbian::getImageQualityDetails(CxeImageDetails &imageInfo)

{

    CX_DEBUG_ENTER_FUNCTION();

    int imageQuality = 0;

    CxeError::Id err = CxeError::None;

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

        err = mSettings.get(CxeSettingIds::IMAGE_QUALITY, imageQuality);

        bool validQuality = (imageQuality >= 0 && imageQuality < mIcmSupportedImageResolutions.count());

        if (err == CxeError::None && validQuality ) {

            // get image quality details

            imageInfo = mIcmSupportedImageResolutions.at(imageQuality);

        } else {

            err = CxeError::NotFound;

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

        }

    } else {

        // we are in secondary camera

        // get secondary camera image quality details

       imageInfo = mIcmSupportedImageResolutions.at(imageQuality);

    }

    CX_DEBUG_EXIT_FUNCTION();

    return err;

}

/**

 * Command to start image capture now.

 */

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.

    mCameraDevice.camera()->CaptureImage();

    if (imagesLeft() > 0) {

        mCaptureSoundPlayer->play();

        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.

 */

{

    CX_DEBUG_ENTER_FUNCTION();

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/**

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

        }

    }

    // Get the image data from the buffer

    TDesC8* data = NULL;

    TRAPD( symbErr, data = cameraBuffer->DataL(0) );

    CX_DEBUG(("dataError: %d, data: 0x%08x", symbErr, data));

    if (!data && !symbErr) {

        symbErr = KErrNoMemory;