/*

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

#include <fbs.h>

#include <QPixmap>

#include <coemain.h>

#include <ECamOrientationCustomInterface2.h>

#include <ecam/camerasnapshot.h>

#include <ecamfacetrackingcustomapi.h>

#include "cxestillcapturecontrolsymbian.h"

#include "cxeimagedataqueuesymbian.h"

#include "cxefilenamegenerator.h"

#include "cxefilesavethread.h"

#include "cxutils.h"

#include "cxesysutil.h"

#include "cxecameradevicecontrol.h"

#include "cxecameradevice.h"

#include "cxesoundplayersymbian.h"

#include "cxestillimagesymbian.h"

#include "cxeviewfindercontrol.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 "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxestillcapturecontrolsymbianTraces.h"

#endif

// constants

const int KMaintainAspectRatio = false;

const TInt64 KMinRequiredSpaceImage = 2000000;

/**

 * Constructor.

 */

CxeStillCaptureControlSymbian::CxeStillCaptureControlSymbian(

        CxeCameraDevice &cameraDevice,

        CxeViewfinderControl &viewfinderControl,

        CxeCameraDeviceControl &cameraDeviceControl,

        CxeFilenameGenerator &nameGenerator,

        CxeSensorEventHandler &sensorEventHandler,

        CxeAutoFocusControl &autoFocusControl,

        CxeSettings &settings,

        CxeQualityPresets &qualityPresets,

        CxeFileSaveThread &fileSaveThread)

: CxeStateMachine("CxeStillCaptureControlSymbian"),

  mCameraDevice(cameraDevice),

  mViewfinderControl(viewfinderControl),

  mCameraDeviceControl(cameraDeviceControl),

  mFilenameGenerator(nameGenerator),

  mSensorEventHandler(sensorEventHandler),

  mAutoFocusControl(autoFocusControl),

  mSettings(settings),

  mQualityPresets(qualityPresets),

  mFileSaveThread(fileSaveThread),

  mMode(SingleImageCapture),

  mAfState(CxeAutoFocusControl::Unknown)

{

    CX_DEBUG_ENTER_FUNCTION();

    qRegisterMetaType<CxeStillCaptureControl::State>();

    initializeStates();

    reset();

    // 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 signals for ECam events

    connect(&mCameraDeviceControl, SIGNAL(cameraEvent(int,int)),

            this, SLOT(handleCameraEvent(int,int)));

    mImageDataQueue = new CxeImageDataQueueSymbian();

    mAutoFocusSoundPlayer = new CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::AutoFocus);

    mCaptureSoundPlayer = new CxeSoundPlayerSymbian(CxeSoundPlayerSymbian::StillCapture);

    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, "msg: e_CX_STILL_CAPCONT_INIT 1");

    if (state() == Uninitialized) {

        prepare();

        // Initialize orientation sensor and other sensors

        mSensorEventHandler.init();

    }

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

    CX_DEBUG_EXIT_FUNCTION();

}

/**

 * Un-initialize the image mode.

 */

void CxeStillCaptureControlSymbian::deinit()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXESTILLCAPTURECONTROLSYMBIAN_DEINIT, "msg: e_CX_STILL_CAPCONT_DEINIT 1" );

    if (state() == Uninitialized) {

        // nothing to do

        return;

    }

    //stop viewfinder

    mViewfinderControl.stop();

    // disable sensor event handler.

    mSensorEventHandler.deinit();

    if (mCameraDevice.cameraSnapshot()) {

        mCameraDevice.cameraSnapshot()->StopSnapshot();

    }

    if (state() == Capturing) {

        mCameraDevice.camera()->CancelCaptureImage();

    }

    setState(Uninitialized);

    OstTrace0( camerax_performance, DUP1_CXESTILLCAPTURECONTROLSYMBIAN_DEINIT, "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, "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, DUP2_CXESTILLCAPTURECONTROLSYMBIAN_PREPARE, "msg: e_CX_PREPARE_IMAGE_CAPTURE 1");

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

        OstTrace0(camerax_performance, DUP3_CXESTILLCAPTURECONTROLSYMBIAN_PREPARE, "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) {

        MCameraFaceTracking *faceTracking = mCameraDevice.faceTracking();

        if (faceTracking) {

            // Enable AF reticule drawing by adaptation

            TRAP_IGNORE(faceTracking->EnableFaceIndicatorsL(ETrue));

        }

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

        // 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, DUP1_CXESTILLCAPTURECONTROLSYMBIAN_PREPARE, "msg: e_CX_STILLCAPCONT_PREPARE 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

/**!

 Prepare still snapshot

 Returns symbian error code.

 */

int CxeStillCaptureControlSymbian::prepareStillSnapshot()

{

    CX_DEBUG_ENTER_FUNCTION();

    CCamera::CCameraSnapshot *cameraSnapshot = mCameraDevice.cameraSnapshot();

    CX_ASSERT_ALWAYS(cameraSnapshot);

    int err = KErrNone;

    // Whether or not we have postcapture on, we need the snapshot for Thumbnail Manager.

    if (cameraSnapshot) {

        // Cancel active snapshot

        cameraSnapshot->StopSnapshot();

        // Prepare snapshot

        CCamera::TFormat snapFormat = CCamera::EFormatFbsBitmapColor16MU;

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

        TRAP(err, cameraSnapshot->PrepareSnapshotL(snapFormat,

                                                   getSnapshotSize(),

                                                   KMaintainAspectRatio));

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

        CX_DEBUG(("PrepareSnapshotL done, err=%d", err));

        // Start snapshot if no errors encountered.

        if (err == KErrNone) {

            CX_DEBUG(("Start still snapshot"));

            cameraSnapshot->StartSnapshot();

        }

    } else {

        // No snapshot interface available. Report error.

        // Assert above takes care of this, but keeping this as an option.

        err = KErrNotReady;

    }

    CX_DEBUG_EXIT_FUNCTION();

    return err;

}

/**!

 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;

}

/*!

* Returns snapshot size. Snapshot size is calculated based on the

* display resolution and current image aspect ratio.

*/

TSize CxeStillCaptureControlSymbian::getSnapshotSize() const

{

    CX_DEBUG_ENTER_FUNCTION();

    TSize snapshotSize;

    QSize deviceResolution = mViewfinderControl.deviceDisplayResolution();

    QSize size = QSize(mCurrentImageDetails.mWidth, mCurrentImageDetails.mHeight);

    // scale according to aspect ratio.

    size.scale(deviceResolution.width(), deviceResolution.height(), Qt::KeepAspectRatio);

    CX_DEBUG(("Still Snapshot size, (%d,%d)", size.width(), size.height()));

    snapshotSize.SetSize(size.width(), deviceResolution.height());

    CX_DEBUG_EXIT_FUNCTION();

    return snapshotSize;

}

/**

 * Command to start image capture now.

 */

void CxeStillCaptureControlSymbian::capture()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_ASSERT_ALWAYS(mCameraDevice.camera());

    // Play the capture sound and start image capture

    mCaptureSoundPlayer->play();

    setState(Capturing);

    mCameraDevice.camera()->CaptureImage();

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

    }

    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;

}

/**

 * Camera events. Only relevant one(s) are handled.

 */

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

{

    CX_DEBUG_ENTER_FUNCTION();

    if (eventUid == KUidECamEventSnapshotUidValue &&

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

        handleSnapshotEvent(CxeErrorHandlingSymbian::map(error));

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/**

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

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

 * order as well.

 */

void CxeStillCaptureControlSymbian::handleSnapshotEvent(CxeError::Id error)

{

    CX_DEBUG_ENTER_FUNCTION();

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

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

        return;

    }

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

    // Get image container for current snapshot index.

    // Remember to increment counter.

    CxeStillImageSymbian* stillImage = getImageForIndex(mNextSnapshotIndex++);

    if (error == CxeError::None) {

        try {

            stillImage->setSnapshot(extractSnapshot());

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

            error = CxeError::General;

        }

    }

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

    emit snapshotReady(error, stillImage->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);

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/**

* Gets QPixmap snapshot from ECAM buffer, if available.

* @param buffer ECAM buffer containing the snapshot data. Will be released when this

* method returns, even on exception.

*/

QPixmap CxeStillCaptureControlSymbian::extractSnapshot()

{

    CX_DEBUG_ENTER_FUNCTION();

    QPixmap pixmap;

    if (mCameraDevice.cameraSnapshot()) {

        QT_TRAP_THROWING({

            RArray<TInt> frameIndex;

            CleanupClosePushL(frameIndex);

            MCameraBuffer &buffer(mCameraDevice.cameraSnapshot()->SnapshotDataL(frameIndex));

            // Make sure buffer is released on leave / exception

            CxeCameraBufferCleanup cleaner(&buffer);

            TInt firstImageIndex(frameIndex.Find(0));

            CFbsBitmap &snapshot(buffer.BitmapL(firstImageIndex));

            CleanupStack::PopAndDestroy(); // frameIndex

            TSize size = snapshot.SizeInPixels();

            TInt sizeInWords = size.iHeight * CFbsBitmap::ScanLineLength(size.iWidth, EColor16MU) / sizeof(TUint32);