/*

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

*

*/

#ifndef CXESTILLCAPTURECONTROL_H

#define CXESTILLCAPTURECONTROL_H

#include <QObject>

#include <QMetaType>

#include <QPixmap>

#include "cxeerror.h"

#include "cxequalitydetails.h"

class CxeStillImage;

class CxeImageDataQueue;

/**

 * Still capture control implements basic still image capture functionality. It

 * automatically plays back the capture sound when capturing images (or a

 * sequence of images) and it also provides snapshots of captured images.

 * Still capture control also automatically makes sure that the images are

 * saved in the file system in the background.

 *

 * The CxeStillImage is used to access information (snapshot image, filename)

 * about captured images. The still capture control owns an array of CxeStillImage

 * objects representing the images that were captured. The CxeStillCaptureControl::reset()

 * function should be used to clear any data about previously captured images and to initialize

 * the control for a new capture.

 *

 * The images will be saved to the file system by CxeImageDataQueue and CxeImageDataItem classes.

 * @sa CxeStillImage

 * @sa CxeImageDataQueue

 * @sa CxeImageDataItem

 */

class CxeStillCaptureControl : public QObject

{

    Q_OBJECT

public:

    /**

     * Image capture mode.

     */

    enum CaptureMode

        {

        //! Single image mode

        SingleImageCapture,

        //! Burst capture mode. One capture operation captures images until

        //! stopped or the maximum amount of images is reached.

        BurstCapture

        };

    //! Still capture control states

    enum State {

        //! Not prepared

        Uninitialized = 0x01,

        //! Prepared and ready to capture images

        Ready         = 0x02,

        //! Capture operation is in progress

        Capturing     = 0x04

        };

    /**

     * Start capturing images.

     */

    virtual void capture() = 0;

    /**

     * Current state.

     */

    virtual State state() const = 0;

    /**

     * Get the number of images captured. The actual images can be accessed

     * using the [] operator.

     *

     * @return Number of CxeStillImage object available

     */

    virtual int imageCount() const = 0;

    /**

     * Clear the image array, destroy all CxeStillImage objects, including

     * snapshot images. Items in the file save queue remain and are saved in

     * the background.

     */

    virtual void reset() = 0;

    /**

     * Clear the image array, destroy all CxeStillImage objects, including

     * snapshot images. File save queue is cleared as well and all unsaved

     * images will be lost.

     */

    virtual void cancelAll() = 0;

    /**

     * Set current image capture mode.

     */

    virtual void setMode(CaptureMode mode) = 0;

    /**

     * Get current image capture mode.

     */

    virtual CaptureMode mode() const = 0;

    /**

     * Access images that were captured during this capture sequence.

     *

     * @param index Image index. Must be 0 <= index < imageCount.

     * @return Reference to corresponding CxeStillImage

     */

    virtual CxeStillImage &operator[]( int index ) = 0;

    /**

     * File save queue

     */

    virtual CxeImageDataQueue& imageDataQueue() = 0;

    /*

    * supported list of image qualities, sorted in descending order based on image resolution

    * i.e. the list has the highest resolution first and so on

    * Internally, we check if we are using Primary/Secondary camera and return the list based on it

    */

    virtual QList<CxeImageDetails> supportedImageQualities() = 0;

    /*

    * Returns the number of images left for the current image quality setting

    */

    virtual int imagesLeft() = 0;

public slots:

    virtual void init() = 0;

    virtual void deinit() = 0;

signals:

    void stateChanged(CxeStillCaptureControl::State newState, CxeError::Id error);

    /**

     * A signal indicating a snapshot image is available.

     *

     * @param error Status code for the snapshot.

     *              CxeError::None if snapshot successfully received.

     * @param snapshot The snapshot image.

     * @param id       Id of the image this snapshot is for.

     */

    void snapshotReady(CxeError::Id error, const QImage &snapshot, int id);

    void imageCaptured(CxeError::Id error, int id);

    /**

    * Amount of images that can be captured has changed.

    */

    void availableImagesChanged();

protected:

    CxeStillCaptureControl() {} // protected empty contructor so that derived class construction works

private:

    Q_DISABLE_COPY( CxeStillCaptureControl )

};

Q_DECLARE_METATYPE(CxeStillCaptureControl::State)

#endif // CXESTILLCAPTURECONTROL_H