src/FMedia_CameraImpl.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                        FMedia_CameraImpl.h
  20  * @brief                       This header file contains the declarations of the %_CameraImpl class.
  21  *
  22  */
  23
  24 #ifndef _FMEDIA_INTERNAL_CAMERA_IMPL_H_
  25 #define _FMEDIA_INTERNAL_CAMERA_IMPL_H_
  26
  27 #include <unique_ptr.h>
  28 #include <camera.h>
  29 #include <FBaseColIList.h>
  30 #include <FBaseColIListT.h>
  31 #include <FBaseObject.h>
  32 #include <FBaseColQueue.h>
  33 #include <FGrpBufferInfo.h>
  34 #include <FGrpDimension.h>
  35 #include <FGrpPixelFormat.h>
  36 #include <FGrpRectangle.h>
  37 #include <FMediaCameraTypes.h>
  38 #include <FMediaTypes.h>
  39 #include <FMediaIVideoStreamFilter.h>
  40 #include "FMedia_CameraTypes.h"
  41 #include "FMedia_CapabilityTypes.h"
  42 #include "FMedia_ICameraCoordinatorListener.h"
  43 #include "FMedia_CameraBuffer.h"
  44 #include "FMedia_CamPtrUtil.h"
  45
  46 namespace Tizen { namespace Media
  47 {
  48 class Camera;
  49 class ICameraEventListener;
  50 class _CameraEvent;
  51 class _CameraCoordinator;
  52 class _CameraCapability;
  53 class _ImageUtilImpl;
  54 class _VideoStreamCoordinator;
  55
  56 /**
  57  * @class       _CameraImpl
  58  * @brief       This class implements the APIs of %Camera class.
  59  *
  60  */
  61 class _CameraImpl
  62         : public Tizen::Base::Object
  63         , public _ICameraCoordinatorListener
  64 {
  65 public:
  66         /**
  67          * This is the default constructor for this class.
  68          *
  69          * @remarks             After creating an instance of this class, the Construct() method must be called explicitly to
  70          * initialize this instance.
  71          * @see                 Construct()
  72          */
  73         _CameraImpl(void);
  74         /**
  75          * This is the destructor for this class. @n
  76          * All allocated resources are deallocated by this method. This method should be called in the same thread
  77          * where the Construct() method is called.
  78          *
  79          * @see                 Construct()
  80          */
  81         virtual ~_CameraImpl(void);
  82
  83
  84         /**
  85         * Initializes this instance of Camera with the specified parameters. @n
  86         * This method creates an instance of Camera in the subsystem. Only one instance is created at a given time.
  87         *
  88         * @return               An error code
  89         * @param[in]    listener                                An event listener instance
  90         * @param[in]    camSel                                  The Camera to be used
  91         * @exception    E_SUCCESS                               The method is successful.
  92         * @exception    E_SYSTEM                                A system error has occurred.
  93         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
  94         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
  95         */
  96         result Construct(ICameraEventListener& listener, CameraSelection camSel);
  97
  98         /**
  99         * Powers the camera on.
 100         *
 101         * @return               An error code
 102         * @exception    E_SUCCESS                               The method is successful.
 103         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 104         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
 105         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
 106         * @exception    E_DEVICE_FAILED                 The device operation has failed.
 107         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 108         * @remarks              The reserved configurations are set in this method.
 109         * @see                  PowerOff()
 110         */
 111         result PowerOn(void);
 112
 113         /**
 114         * Powers the camera off.
 115         *
 116         * @return               An error code
 117         * @exception    E_SUCCESS                               The method is successful.
 118         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 119         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
 120         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
 121         * @exception    E_DEVICE_FAILED                 The device operation has failed.
 122         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 123         * @see                  PowerOn()
 124         */
 125         result PowerOff(void);
 126
 127         /**
 128         * Checks whether the camera is powered on.
 129         *
 130         * @return               @c true if the camera is powered on, @n
 131         *                               else @c false
 132         * @exception    E_SUCCESS                               The method is successful.
 133         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 134         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 135         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 136         * @see                  PowerOn(), PowerOff()
 137         */
 138         bool IsPoweredOn(void) const;
 139
 140         /**
 141         * Starts displaying the preview image on the camera device. @n
 142         * If the value of @c pBufferInfo is @c null, no preview image is displayed. In this case, the application can
 143         * draw the preview image with the data passed on by the ICameraEventListener::OnCameraPreviewed() method.
 144         *
 145         * If the value of @c previewedData is @c true, the previewed image data is passed to the
 146         * ICameraEventListener::OnCameraPreviewed() method periodically based on the frame-rate, otherwise the
 147         * callback is not invoked. The default value of @c previewedData is @c false.
 148         *
 149         * @return               An error code
 150         * @param[in]    pBufferInfo                             The buffer information for the camera preview display
 151         * @param[in]    previewedData                   Set to @c true if the previewed data is delivered to the callback method, @n
 152         *                                                                               else @false
 153         * @exception    E_SUCCESS                               The method is successful.
 154         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 155         * @exception    E_UNSUPPORTED_FORMAT    The specified format is not supported.
 156         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
 157         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
 158         * @exception    E_DEVICE_FAILED                 The device operation has failed.
 159         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 160         * @remarks              The overlay region retrieved by the buffer information should be the topmost window when this method is
 161         *                               called.
 162         * @remarks              The ICameraEventListener::OnCameraPreviewed() method can be delayed or dropped depending on
 163         *                               the system's performance. @n@n
 164         *                               For more information on the relationship between this method and the PowerOn() method, and the
 165         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 166         ">Launching the Camera</a>.
 167
 168         * @see                  StopPreview(), ICameraEventListener::OnCameraPreviewed()
 169         */
 170         result StartPreview(const Tizen::Graphics::BufferInfo* pBufferInfo, bool previewedData = false);
 171
 172         /**
 173         * Stops displaying the preview image on the camera device.
 174         *
 175         * @return               An error code
 176         * @exception    E_SUCCESS                               The method is successful.
 177         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 178         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
 179         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
 180         * @exception    E_DEVICE_FAILED                 The device operation has failed.
 181         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 182         * @remarks        For more information on the relationship between this method and the PowerOn() method, and the
 183         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 184         ">Launching the Camera</a>.
 185         * @see                  StartPreview()
 186         */
 187         result StopPreview(void);
 188
 189         /**
 190         * Captures the current image data from the camera sensor. @n
 191         * After capturing the image, the camera's state changes to ::CAMERA_STATE_CAPTURED. @n
 192         * The camera's preview should be restarted by calling the StartPreview() method. @n
 193         * The captured image is passed through ICameraEventListener::OnCameraCaptured().
 194         *
 195         * @return               An error code
 196         * @exception    E_SUCCESS                                       The method is successful.
 197         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 198         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 199         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 200         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 201         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 202         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 203         * @remarks        For more information on the relationship between this method and the PowerOn() method, and the
 204         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 205         ">Launching the Camera</a>.
 206         * @see                  ICameraEventListener::OnCameraCaptured()
 207         */
 208         result Capture(void);
 209
 210         /**
 211         * Gets the state of the camera in CameraState.
 212         *
 213         * @return               The current state of the camera
 214         * @exception    E_SUCCESS                                       The method is successful.
 215         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 216         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 217         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 218         * @see                  StartPreview(), StopPreview(), SetAutoFocus(), Capture()
 219         */
 220         CameraState GetState(void) const;
 221
 222         /**
 223         * Sets the brightness level of the camera input data.
 224         *
 225         * @return               An error code
 226         * @param[in]    brightness                                      The brightness level to set @n
 227         *                                                                                       The range of this parameter is from @c 0 to @c 9.
 228         * @exception    E_SUCCESS                                       The method is successful.
 229         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 230         * @exception    E_OUT_OF_RANGE                          The specified @c brightness is out of range.
 231         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 232         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 233         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 234         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 235         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 236         * @remarks              The default brightness level is @c 5. @n
 237         *                               The device's supported range for the brightness level is from @c 0 to @c 9. @n
 238         *                               This method works correctly when PowerOn() is executed. @n@n
 239         *                               For more information on the relationship between this method and the PowerOn() method, and the
 240         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 241         ">Launching the Camera</a>.
 242         * @see                  GetBrightness()
 243         */
 244         result SetBrightness(int brightness);
 245
 246         /**
 247         * Gets the brightness level of the camera input data.
 248         *
 249         * @return               The current brightness level @n
 250         *                               The returned value ranges from @c 0 to @c 9.
 251         * @exception    E_SUCCESS                               The method is successful.
 252         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 253         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 254         * @remarks              The specific error code can be accessed using the GetLastResult() method. @n
 255         *                               The device's supported range for the brightness level is from @c 0 to @c 9. @n
 256         * @see                  SetBrightness()
 257         */
 258         int GetBrightness(void) const;
 259
 260         /**
 261         * Sets the contrast level of the Camera input data.
 262         *
 263         * @return               An error code
 264         * @param[in]    contrast                                        The contrast level to set @n
 265         *                                                                                       The range of this parameter is from @c 0 to @c 9.
 266         * @exception    E_SUCCESS                                       The method is successful.
 267         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 268         * @exception    E_OUT_OF_RANGE                          The specified contrast is out of range.
 269         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 270         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 271         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 272         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 273         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 274         * @remarks              The default contrast level is @c 5. @n
 275         *                               The device's supported range for the contrast level is from @c 0 to @c 9. @n
 276         *                               This method works correctly when PowerOn() is executed. @n@n
 277         *                               For more information on the relationship between this method and the PowerOn() method, and the
 278         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 279         ">Launching the Camera</a>.
 280         * @see                  GetContrast()
 281         */
 282         result SetContrast(int contrast);
 283
 284         /**
 285         * Gets the contrast level of the camera input data.
 286         *
 287         * @return               The current contrast level @n
 288         *                               The returned value ranges from @c 0 to @c 9.
 289         * @exception    E_SUCCESS                               The method is successful.
 290         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 291         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 292         * @remarks              The specific error code can be accessed using the GetLastResult() method. @n
 293         *                               The device's supported range for the contrast level is from @c 0 to @c 9.
 294         * @see                  SetContrast()
 295         */
 296         int GetContrast(void) const;
 297
 298         /**
 299         * Increases the zoom level of the camera.
 300         *
 301         * @return               An error code
 302         * @exception    E_SUCCESS                                       The method is successful.
 303         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 304         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 305         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 306         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 307         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 308         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 309         * @remarks              This method returns E_UNSUPPORTED_OPERATION in the emulator.
 310         *                               If CameraZoomType supports only ::CAMERA_ZOOM_TYPE_SMART, the zoom ratio can differ according
 311         *                               to the preview, capture, and recording resolutions.
 312         *                               The supported zoom types can be obtained by using the
 313         *                               MediaCapability::GetValueN(CAMERA_PRIMARY_ZOOM_TYPE) method. @n@n
 314         *                          For more information on the relationship between this method and the PowerOn() method, and the
 315         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 316         ">Launching the Camera</a>.
 317         * @see                  ZoomOut(),GetZoomLevel(),GetMaxZoomLevel()
 318         */
 319         result ZoomIn(void);
 320
 321         /**
 322         * Decreases the zoom level of the camera.
 323         *
 324         * @return               An error code
 325         * @exception    E_SUCCESS                                       The method is successful.
 326         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 327         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 328         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 329         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 330         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 331         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 332         * @remarks              This method returns E_UNSUPPORTED_OPERATION in the emulator.
 333         *                               If CameraZoomType supports only ::CAMERA_ZOOM_TYPE_SMART, zoom ratio can differ according to
 334         *                               the preview, capture, and recording resolutions.
 335         *                               The supported zoom types can be obtained by using the
 336         *                               MediaCapability::GetValueN(CAMERA_PRIMARY_ZOOM_TYPE) method. @n@n
 337         *                          For more information on the relationship between this method and the PowerOn() method, and the
 338         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 339         ">Launching the Camera</a>.
 340         * @see                  ZoomIn(),GetZoomLevel(),GetMaxZoomLevel()
 341         */
 342         result ZoomOut(void);
 343
 344         /**
 345         * Gets the zoom level of the camera.
 346         *
 347         * @return               The current zoom level
 348         * @exception    E_SUCCESS                               The method is successful.
 349         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 350         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 351         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 352         * @remarks              The zoom level is different for each camera device.
 353         * @remarks              This method throws E_UNSUPPORTED_OPERATION in the emulator.
 354         * @see                  ZoomIn(), ZoomOut(),GetMaxZoomLevel()
 355         */
 356         int GetZoomLevel(void) const;
 357
 358         /**
 359         * Gets the maximum zoom level supported by this Camera.
 360         *
 361         * @return               The maximum zoom level
 362         * @exception    E_SUCCESS                               The method is successful.
 363         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 364         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 365         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 366         * @remarks              The zoom level is different for each camera device.
 367         * @remarks              This method returns E_UNSUPPORTED_OPERATION in the emulator. @n
 368         *                               This method works correctly when PowerOn() is executed.
 369         * @see                  ZoomIn(), ZoomOut(), GetZoomLevel()
 370         */
 371         int GetMaxZoomLevel(void) const;
 372
 373         /**
 374         * Changes the current resolution of the preview.
 375         *
 376         * @return               An error code
 377         * @param[in]    resolution                                The preview resolution @n
 378         *                                                                                       It should be one of the listed dimensions that are extracted using GetSupportedPreviewResolutionListN().
 379         * @exception    E_SUCCESS                                       The method is successful.
 380         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 381         * @exception    E_OUT_OF_RANGE                          The position or size is out of range.
 382         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 383         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 384         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 385         * @exception    E_UNSUPPORTED_OPERATION         This operation is not supported.
 386         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 387         * @remarks              This method works in the ::CAMERA_STATE_INITIALIZED state. @n@n
 388         *                               For more information on the relationship between this method and the PowerOn() method, and the
 389         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 390         ">Launching the Camera</a>.
 391         * @see                  GetPreviewResolution()
 392         */
 393         result SetPreviewResolution(const Tizen::Graphics::Dimension& resolution);
 394
 395         /**
 396         * Retrieves the current resolution of the preview.
 397         *
 398         * @return               The current preview resolution
 399         * @exception    E_SUCCESS                               The method is successful.
 400         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 401         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 402         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 403         * @see                  SetPreviewResolution()
 404         */
 405         Tizen::Graphics::Dimension GetPreviewResolution(void) const;
 406
 407         /**
 408         * Retrieves the supported preview resolution list of the Camera class. @n
 409         * Each item in the returned list contains a pointer of Tizen::Graphics::Dimension value.
 410         *
 411         * @return          A list of dimensions that represent the preview resolutions supported by the Camera class,  @n
 412         *                               else @c null if no preview resolution is supported or an exception occurs
 413         * @exception    E_SUCCESS                               The method is successful.
 414         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 415         * @exception    E_SYSTEM                                A system error has occurred.
 416         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 417         * @remark               The specific error code can be accessed using the GetLastResult() method. @n
 418         *                               The return value and each item in the list must be deleted by the caller. @n
 419         *                               This method works correctly when Camera::PowerOn() is executed.
 420         * @see                  SetPreviewResolution(), GetPreviewResolution()
 421         */
 422         Tizen::Base::Collection::IList* GetSupportedPreviewResolutionListN(void) const;
 423
 424
 425         /**
 426         * Sets the capturing resolution of the camera. @n
 427         * Initially, the default resolution is set using the internal configuration.
 428         *
 429         * @return               An error code
 430         * @param[in]    resolution                                      The display resolution @n
 431         *                                                                                       The display resolution should be one of the values extracted using GetSupportedCaptureResolutionListN().
 432         * @exception    E_SUCCESS                                       The method is successful.
 433         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 434         * @exception    E_SYSTEM                                        A system error has occurred.
 435         * @exception    E_OUT_OF_RANGE                          The specified resolution is out of range.
 436         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 437         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 438         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 439         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 440         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 441         * @remarks                      For more information on the relationship between this method and the PowerOn() method, and the
 442         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 443         ">Launching the Camera</a>.
 444         * @see                  GetCaptureResolution(), GetSupportedCaptureResolutionListN()
 445         */
 446         result SetCaptureResolution(const Tizen::Graphics::Dimension& resolution);
 447
 448         /**
 449         * Gets the resolution for capturing the data of the camera.
 450         *
 451         * @return               The current resolution for capturing the data of the camera
 452         * @exception    E_SUCCESS                               The method is successful.
 453         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 454         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 455         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 456         * @see                  SetCaptureResolution(),GetSupportedCaptureResolutionListN()
 457         */
 458         Tizen::Graphics::Dimension GetCaptureResolution(void) const;
 459
 460         /**
 461         * Gets a list of the capturing resolutions supported by the Camera class. @n
 462         * Each item of the list has a pointer of the Tizen::Graphics::Dimension value.
 463         *
 464         * @return               A list of the capture resolutions supported by the Camera class @n
 465         *                               else @c null if no capture resolution is supported or an exception occurs
 466         * @exception    E_SUCCESS                               The method is successful.
 467         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 468         * @exception    E_SYSTEM                                A system error has occurred.
 469         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 470         * @remark               The specific error code can be accessed using the GetLastResult() method. @n
 471         *                               The return value and each item in the list must be deleted by the caller. @n
 472         *                               This method works correctly when PowerOn() is executed.
 473         * @see                  SetCaptureResolution(), GetCaptureResolution()
 474         */
 475         Tizen::Base::Collection::IList* GetSupportedCaptureResolutionListN(void) const;
 476
 477         /**
 478         * Sets the effect for the input data of the camera.
 479         *
 480         * @return               An error code
 481         * @param[in]    effect                                          The effect for the input data of the camera
 482         * @exception    E_SUCCESS                                       The method is successful.
 483         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 484         * @exception    E_INVALID_ARG                           The specified input parameter is invalid.
 485         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 486         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 487         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 488         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 489         * @exception    E_UNSUPPORTED_TYPE                The effect type is not supported.
 490         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 491         * @remarks              The default effect is ::CAMERA_EFFECT_NONE.
 492         *                               This method works correctly when PowerOn() is executed. @n@n
 493         *                               For more information on the relationship between this method and the PowerOn() method, and the
 494         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 495         ">Launching the Camera</a>.
 496         * @see                  GetEffect()
 497         */
 498         result SetEffect(CameraEffect effect);
 499
 500         /**
 501         * Gets the effect for the input data of the camera.
 502         *
 503         * @return               The effect for the input data of the camera
 504         * @exception    E_SUCCESS                                       The method is successful.
 505         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 506         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 507         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 508         * @see                  SetEffect()
 509         */
 510         CameraEffect GetEffect(void) const;
 511
 512         /**
 513         * Sets the camera's flash mode.
 514         *
 515         * @return               An error code
 516         * @param[in]    flashMode                                       flash mode to switch on the flash light.
 517         * @exception    E_SUCCESS                                       The method is successful.
 518         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 519         * @exception    E_INVALID_ARG                           The specified flash mode is invalid.
 520         * @exception    E_DEVICE_BUSY                           The camera is under use by other application.
 521         * @exception    E_DEVICE_UNAVAILABLE            The camera becomes unavailable.
 522         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 523         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 524         * @exception    E_UNSUPPORTED_OPERATION     The target device does not support flash configuration feature.
 525         * @exception    E_UNSUPPORTED_TYPE          The specified @c flashMode is not supported.
 526         * @remarks              Normally the flash splashes before the camera captures a picture. @n
 527         *                               ::CAMERA_FLASH_MODE_CONTINUOUS keeps the flash turned on after the method is called until ::CAMERA_FLASH_MODE_OFF is set. @n
 528         *                               This method returns E_UNSUPPORTED_OPERATION in the Emulator.
 529         * @see                  GetFlashMode()
 530         */
 531         result SetFlashMode(CameraFlashMode flashMode);
 532
 533         /**
 534         * Gets the flash mode of the camera.
 535         *
 536         * @return               The flash mode of the camera
 537         * @exception    E_SUCCESS                                       The method is successful.
 538         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 539         *                               If the %Camera doesn't support the flash mode, this method always returns ::CAMERA_FLASH_MODE_OFF.
 540         * @see                  SetFlashMode()
 541         */
 542         CameraFlashMode GetFlashMode(void) const;
 543
 544         /**
 545         * Sets the exposure level of the camera.
 546         *
 547         * @return               An error code
 548         * @param[in]    exposure                                        The camera exposure level @n
 549         *                                                                                       The range of this parameter is from @c 0 to @c 9.
 550         * @exception    E_SUCCESS                                       The method is successful.
 551         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 552         * @exception    E_OUT_OF_RANGE                          The specified exposure level is out of range.
 553         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 554         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 555         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 556         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 557         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 558         * @remarks              The default exposure level is @c 5.
 559         *                               The supported range for exposure level is from @c 0 to @c 9.
 560         *                               This method works correctly when PowerOn() is executed. @n@n
 561         *                               For more information on the relationship between this method and the PowerOn() method, and the
 562         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 563         ">Launching the Camera</a>.
 564         * @see                  GetExposure()
 565         */
 566         result SetExposure(int exposure);
 567
 568         /**
 569         * Gets the exposure level of the camera.
 570         *
 571         * @return               An integer value representing the exposure level of the camera @n
 572         *                               The returned value ranges from @c 0 to @c 9.
 573         * @exception    E_SUCCESS                               The method is successful.
 574         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 575         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 576         * @remarks              The specific error code can be accessed using the GetLastResult() method. @n
 577         *                               The supported range for exposure level is from @c 0 to @c 9.
 578         * @see                  SetExposure()
 579         */
 580         int GetExposure(void) const;
 581
 582         /**
 583         * Sets the white balance level of the camera.
 584         *
 585         * @return               An error code
 586         * @param[in]    whiteBalance                            The camera white balance level
 587         * @exception    E_SUCCESS                                       The method is successful.
 588         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 589         * @exception    E_INVALID_ARG                           The specified input parameter is invalid.
 590         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 591         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 592         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 593         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 594         * @exception    E_UNSUPPORTED_TYPE                The @c whiteBalance type is not supported.
 595         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 596         * @remarks              The default white balance is ::CAMERA_WHITE_BALANCE_AUTO.
 597         *                               This method works correctly when PowerOn() is executed. @n@n
 598         *                               For more information on the relationship between this method and the PowerOn() method, and the
 599         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 600         ">Launching the Camera</a>.
 601         * @see                  GetWhiteBalance()
 602         */
 603
 604         result SetWhiteBalance(CameraWhiteBalance whiteBalance);
 605
 606         /**
 607         * Gets the white balance level of the camera.
 608         *
 609         * @return               The white balance level of the camera
 610         * @exception    E_SUCCESS                               The method is successful.
 611         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 612         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 613         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 614         * @see                  SetWhiteBalance()
 615         */
 616         CameraWhiteBalance GetWhiteBalance(void) const;
 617
 618         /**
 619         * Sets the capturing quality of the camera.
 620         *
 621         * @return               An error code
 622         * @param[in]    quality                                         The camera's quality level
 623         * @exception    E_SUCCESS                                       The method is successful.
 624         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 625         * @exception    E_INVALID_ARG                           The specified @c quality is not supported.
 626         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 627         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 628         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 629         * @exception    E_UNSUPPORTED_OPERATION         This operation is not supported.
 630         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 631         * @remarks              The default quality is ::CAMERA_QUALITY_NORMAL.
 632         *                               This method works correctly when PowerOn() is executed. @n@n
 633         *                               For more information on the relationship between this method and the PowerOn() method, and the
 634         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 635         ">Launching the Camera</a>.
 636         * @see                  GetQuality()
 637         */
 638         result SetQuality(CameraQuality quality);
 639
 640         /**
 641         * Gets the capturing quality of the camera.
 642         *
 643         * @return               The Camera quality level
 644         * @exception    E_SUCCESS                                       The method is successful.
 645         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 646         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 647         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 648         * @see                  SetQuality()
 649         */
 650         CameraQuality GetQuality(void) const;
 651
 652         /**
 653         * Sets the focus mode of the camera.
 654         *
 655         * @return               An error code
 656         * @param[in]    focusMode                               focus mode
 657         * @exception    E_SUCCESS                                       The method is successful.
 658         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 659         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 660         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 661         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 662         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 663         * @exception    E_UNSUPPORTED_TYPE                The @c focusMode type is not supported.
 664         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 665         * @remarks      ::CAMERA_FOCUS_MODE_NONE always throws E_INVALID_ARG.
 666         * @see          GetFocusMode()
 667         */
 668         result SetFocusMode(CameraFocusMode focusMode);
 669
 670         /**
 671         * Gets the focus mode of the camera.
 672         *
 673         * @return               The %Camera focus mode
 674         * @see          SetFocusMode()
 675         */
 676         CameraFocusMode GetFocusMode(void) const;
 677
 678         /**
 679         * Enables or disables the auto focus mode of the camera.
 680         *
 681         * @return               An error code
 682         * @param[in]    callback                                        Set to @c true to enable auto focus callback, @n
 683         *                                                                                       else @c false
 684         * @exception    E_SUCCESS                                       The method is successful.
 685         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 686         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 687         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 688         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 689         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 690         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 691         * @remarks              If @c callback is set to @c false, the ICameraEventListener::OnCameraAutoFocused() method is not called.
 692         *                               This method throws E_UNSUPPORTED_OPERATION in the emulator. @n@n
 693         *                          For more information on the relationship between this method and the PowerOn() method, and the
 694         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 695         ">Launching the Camera</a>.
 696         * @see                  ICameraEventListener::OnCameraAutoFocused()
 697         */
 698         result SetAutoFocus(bool callback);
 699
 700         /**
 701         * Check the object is ready to call the auto focus callback or not.
 702         *
 703         * @return               true if it calls the callback, otherwise false.
 704         */
 705         bool ReadyToAutoFocusCallback(void) const;
 706
 707         /**
 708         * Sets the auto focus point list.
 709         *
 710         * @return           An error code
 711         * @param[in]        pointList                                          auto focus point list which consists of Tizen::Graphics::Point pointers
 712         * @exception        E_SUCCESS                                                                The method is successful.
 713         * @exception        E_INVALID_STATE                                           This instance is in an invalid state for this method.
 714         * @exception        E_DEVICE_BUSY                                             The device cannot be approached because of other operations.
 715         * @exception        E_DEVICE_UNAVAILABLE                    The device is unavailable.
 716         * @exception        E_DEVICE_FAILED                                           The device operation has failed.
 717         * @exception        E_INVALID_ARG                               The specified input parameter is invalid.
 718         * @exception        E_UNSUPPORTED_OPERATION         The device does not support the focus point.
 719         * @exception        E_UNSUPPORTED_TYPE                        This method is not supported for the current focus mode.
 720         * @exception        E_OUT_OF_MEMORY                                                    The memory is insufficient.
 721         * @remarks              This method works fine when the current focus mode is CAMERA_FOCUS_MODE_NORMAL or CAMRA_FOCUS_MODE_MACRO.
 722         * @see                 GetAutoFocusPointN()
 723         */
 724         result SetAutoFocusPoint(const Tizen::Base::Collection::IList& pointList);
 725
 726         /**
 727         * Gets the auto focus point list. @n
 728         * Each item of the list has a pointer of the Tizen::Graphics::Point value.
 729         *
 730         * @return               A list of dimensions that represent the auto focus point, @n
 731         *                               else @c null if no auto focus point is set or an exception occurs
 732         * @exception    E_SUCCESS                                                                The method is successful.
 733         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 734         * @remarks           The specific error code can be accessed using the GetLastResult() method. @n
 735         *                                       The return value and each item in the list must be deleted by the caller.
 736         * @see                 SetAutoFocusPoint()
 737         */
 738         Tizen::Base::Collection::IList* GetAutoFocusPointN(void) const;
 739
 740         /**
 741         * Sets the capturing format of the camera. @n
 742         * Initially, the default format is set using the internal configuration.
 743         *
 744         * @return               An error code
 745         * @param[in]    format                                          The camera's capture format @n
 746         *                                                                                       It should be one of the pixel formats extracted using GetSupportedCaptureFormatListN().
 747         * @exception    E_SUCCESS                                       The method is successful.
 748         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 749         * @exception    E_SYSTEM                                        A system error has occurred.
 750         * @exception    E_UNSUPPORTED_FORMAT            The specified format is not supported.
 751         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 752         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 753         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 754         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 755         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 756         * @remarks              This method works correctly when PowerOn() is executed.
 757         * @see                  GetCaptureFormat(), GetSupportedCaptureFormatListN()
 758         */
 759         result SetCaptureFormat(const Tizen::Graphics::PixelFormat format);
 760
 761         /**
 762         * Gets the capturing format of the camera.
 763         *
 764         * @return               The capturing format of the camera
 765         * @exception    E_SUCCESS                               The method is successful.
 766         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 767         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 768         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 769         * @see                  SetCaptureFormat(), GetSupportedCaptureFormatListN()
 770         */
 771         Tizen::Graphics::PixelFormat GetCaptureFormat(void) const;
 772
 773         /**
 774         * Gets the supported capturing format list for the Camera class. @n
 775         * Each list item has a Tizen::Graphics::PixelFormat value.
 776         *
 777         * @return               A list of the formats supported by the Camera class, @n
 778         *                               else @c null if no capture format is supported or an exception occurs
 779         * @exception    E_SUCCESS                               The method is successful.
 780         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 781         * @exception    E_SYSTEM                                A system error has occurred.
 782         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 783         * @remark               The specific error code can be accessed using the GetLastResult() method. @n
 784         *                               The return value must be deleted. @n
 785         *                               This method works correctly when PowerOn() is executed.
 786         * @see                  SetCaptureFormat(), GetCaptureFormat()
 787         */
 788         Tizen::Base::Collection::IListT<Tizen::Graphics::PixelFormat>* GetSupportedCaptureFormatListN(void) const;
 789
 790         /**
 791         * Sets the preview format of the camera. @n
 792         * Initially, the default format is set using the internal configuration.
 793         *
 794         * @return               An error code
 795         * @param[in]    format                                          The camera's preview format @n
 796         *                                                                                       It should be one of the pixel formats extracted using GetSupportedPreviewFormatListN().
 797         * @exception    E_SUCCESS                                       The method is successful.
 798         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 799         * @exception    E_SYSTEM                                        A system error has occurred.
 800         * @exception    E_UNSUPPORTED_FORMAT            The specified format is not supported.
 801         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 802         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 803         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 804         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 805         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 806         * @remarks              This method works in ::CAMERA_STATE_INITIALIZED state. @n@n
 807         *                               For more information on the relationship between this method and the PowerOn() method, and the
 808         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 809         ">Launching the Camera</a>.
 810         * @see                  GetPreviewFormat(), GetSupportedPreviewFormatListN()
 811         */
 812         result SetPreviewFormat(const Tizen::Graphics::PixelFormat format);
 813
 814         /**
 815         * Gets the preview format of the camera.
 816         *
 817         * @return               The preview format of the camera
 818         * @exception    E_SUCCESS                               The method is successful.
 819         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 820         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 821         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 822         * @see                  SetPreviewFormat(), GetSupportedPreviewFormatListN()
 823         */
 824         Tizen::Graphics::PixelFormat GetPreviewFormat(void) const;
 825
 826         /**
 827         * Gets the supported preview format list for the Camera class. @n
 828         * Each list item has a Tizen::Graphics::PixelFormat value.
 829         *
 830         * @return               A list of the preview format supported by the Camera class, @n
 831         *                               else @c null if no preview format is supported or an exception occurs
 832         * @exception    E_SUCCESS                               The method is successful.
 833         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 834         * @exception    E_SYSTEM                                A system error has occurred.
 835         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 836         * @remark               The specific error code can be accessed using the GetLastResult() method. @n
 837         *                               The return value must be deleted. @n
 838         *                               This method works correctly when PowerOn() is executed.
 839         * @see                  SetPreviewFormat(), GetPreviewFormat()
 840         */
 841         Tizen::Base::Collection::IListT<Tizen::Graphics::PixelFormat>* GetSupportedPreviewFormatListN(void) const;
 842
 843
 844         /**
 845         * Sets the ISO level of the camera.
 846         *
 847         * @return               An error code
 848         * @param[in]    isoLevel                                        The camera's ISO level @n
 849         *                                                                                       The default ISO level is set from the internal configuration.
 850         * @exception    E_SUCCESS                                       The method is successful.
 851         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 852         * @exception    E_OUT_OF_RANGE                          The specified ISO level is out of range.
 853         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 854         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 855         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 856         * @exception    E_UNSUPPORTED_OPERATION         This operation is not supported.
 857         * @exception    E_UNSUPPORTED_TYPE                The specified @c isoLevel is not supported.
 858         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 859         * @remarks              In some devices this method works in the ::CAMERA_STATE_PREVIEW state.
 860         *                               This method throws E_UNSUPPORTED_OPERATION in the emulator. @n@n
 861         *                               For more information on the relationship between this method and the PowerOn() method, and the
 862         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 863         ">Launching the Camera</a>.
 864         * @see                  GetIsoLevel()
 865         */
 866         result SetIsoLevel(CameraIsoLevel isoLevel);
 867
 868         /**
 869         * Gets the ISO level of the camera.
 870         *
 871         * @return               The ISO level of the camera
 872         * @exception    E_SUCCESS                               The method is successful.
 873         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 874         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 875         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 876         * @see                  SetIsoLevel()
 877         */
 878         CameraIsoLevel GetIsoLevel(void) const;
 879
 880         /**
 881         * Sets the preview frame rate of the camera. @n
 882         * Initially, the default frame rate is set using the internal configuration.
 883         *
 884         * @return               An error code
 885         * @param[in]    fps                                                     The frame rate per second
 886         * @exception    E_SUCCESS                                       The method is successful.
 887         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 888         * @exception    E_OUT_OF_RANGE                          The specified @c fps is out of range on this device.
 889         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 890         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 891         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 892         * @exception    E_UNSUPPORTED_OPERATION         This operation is not supported.
 893         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 894         * @remarks              This method works in ::CAMERA_STATE_INITIALIZED state. @n@n
 895         *                               For more information on the relationship between this method and the PowerOn() method, and the
 896         *                          state transition caused by this method, see <a href="../com.osp.cppprogramming.help/html/dev_guide/media/launching_camera.htm
 897         ">Launching the Camera</a>.
 898         * @see                  GetPreviewFrameRate(), GetSupportedPreviewFrameRateListN(), FRAME_RATE_AUTO
 899         */
 900         result SetPreviewFrameRate(int fps);
 901
 902         /**
 903         * Retrieves the frame rate of the camera.
 904         *
 905         * @return               The frame rate of the camera @n
 906         *                          If the frame rate is not set using SetPreviewFrameRate(), the system-dependent default frame rate is returned.
 907         * @exception    E_SUCCESS                               The method is successful.
 908         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 909         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 910         * @remarks              The specific error code can be accessed using the GetLastResult() method.
 911         * @see                  SetPreviewFrameRate(), GetSupportedPreviewFrameRateListN()
 912         */
 913         int GetPreviewFrameRate(void) const;
 914
 915         /**
 916         * Gets the supported preview frame rate list for the Camera class. @n
 917         * Each list item has an integer value.
 918         *
 919         * @return               A list of the preview frame rate supported by the Camera class, @n
 920         *                               else @c null if no frame rate is supported or an exception occurs
 921         * @exception    E_SUCCESS                               The method is successful.
 922         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 923         * @exception    E_SYSTEM                                A system error has occurred.
 924         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 925         * @remark               The specific error code can be accessed using the GetLastResult() method. @n
 926         *                               The return value must be deleted by the caller. @n
 927         *                               This method works correctly when PowerOn() is executed. @n
 928         *                               This method returns fps list that can be supported by all resolutions.
 929         * @see                  SetPreviewFrameRate(), GetPreviewFrameRate(), FRAME_RATE_AUTO
 930         * @see                  GetSupportedPreviewFrameRateListN(const Tizen::Graphics::Dimension& dim) const
 931         */
 932         Tizen::Base::Collection::IListT<int>* GetSupportedPreviewFrameRateListN(void) const;
 933
 934         /**
 935         * Gets the supported preview frame rate list of the input resolution of the Camera class. @n
 936         * Each item of the list has an integer value.
 937         *
 938         * @return               A list of the preview frame rate of the input preview resolution, @n
 939         *                               else @c null if no frame rate is supported or an exception occurs
 940         * @param[in]    dim                                             The preview resolution of the camera
 941         * @exception    E_SUCCESS                               The method is successful.
 942         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
 943         * @exception    E_INVALID_ARG                   The specified input resolution is invalid.
 944         * @exception    E_SYSTEM                                A system error has occurred.
 945         * @exception    E_OUT_OF_MEMORY                 The memory is insufficient.
 946         * @remark               The specific error code can be accessed using the GetLastResult() method. @n
 947         *                               The return value must be deleted by the caller. @n
 948         *                               This method works correctly when PowerOn() is executed.
 949         * @see                  SetPreviewFrameRate(), GetPreviewFrameRate()
 950         * @see                  GetSupportedPreviewFrameRateListN(void) const
 951         */
 952         Tizen::Base::Collection::IListT<int>* GetSupportedPreviewFrameRateListN(const Tizen::Graphics::Dimension& dim) const;
 953
 954         /**
 955         * Sets the orientation value in the Exchangeable Image File Format (EXIF) field of the captured data.
 956         *
 957         * @return               An error code
 958         * @param[in]    orientation                                     The orientation value to set in EXIF
 959         * @exception    E_SUCCESS                                       The method is successful.
 960         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 961         * @exception    E_OUT_OF_RANGE                          The input value is out of range.
 962         * @exception    E_UNSUPPORTED_OPERATION         This operation is not supported.
 963         * @exception    E_SYSTEM                                        A system error has occurred.
 964         * @remarks              The default value of orientation is CAMERA_EXIF_ORIENTATION_TOP_LEFT. @n
 965         *                               This method works correctly when PowerOn() is executed. The orientation value set by this method can be obtained using the
 966         *                               Tizen::Content::ImageData::GetOrientation() method after writing the captured data to a file.
 967         */
 968         result SetExifOrientation(CameraExifOrientation orientation);
 969
 970         /**
 971         * Sets the GPS coordinates in the Exchangeable Image File Format (EXIF) field for the captured data.
 972         *
 973         * @return               An error code
 974         * @param[in]    latitude                                        The latitude value to be set in EXIF @n
 975         *                                                                                       The valid range is [-90.0, 90.0].
 976         * @param[in]    longitude                                       The longitude value to be set in EXIF @n
 977         *                                                                                       The valid range is [-180.0, 180.0]
 978         * @param[in]    altitude                                        The altitude value to be set in EXIF
 979         * @exception    E_SUCCESS                                       The method is successful.
 980         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 981         * @exception    E_OUT_OF_RANGE                          The input value is out of range.
 982         * @exception    E_UNSUPPORTED_OPERATION         This operation is not supported.
 983         * @exception    E_SYSTEM                                        A system error has occurred.
 984         * @remarks              This method sets the GPS coordinates and enables entering the coordinates into the Exchangeable Image File Format (EXIF).
 985         * @remarks              By default, the GPS coordinates are not entered in JPEG's EXIF.
 986         * @remarks              The GPS coordinates that are set using this method are entered in every call to the
 987         *                               Capture() method, until DisableExifGpsCoordinates() is called or this instance is destroyed. @n
 988         *                               This method works correctly when PowerOn() is executed. @n
 989         *                               The values set by this method can result in an error as compared to the values stored in the Exchangeable Image File Format (EXIF) field.
 990         * @see                  DisableExifGpsCoordinates()
 991         */
 992         result SetExifGpsCoordinates(double latitude, double longitude, float altitude);
 993
 994         /**
 995         * Disables the insertion of the GPS coordinates in the Exchangeable Image File Format (EXIF) field for the captured data.
 996         *
 997         * @return               An error code
 998         * @exception    E_SUCCESS                                       The method is successful.
 999         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
1000         * @exception    E_OUT_OF_RANGE                          The input value is out of range.
1001         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
1002         * @exception    E_SYSTEM                                        A system error has occurred.
1003         * @see            SetExifGpsCoordinates()
1004         */
1005         result DisableExifGpsCoordinates(void);
1006
1007         /**
1008         * Sets the flip type for the previewed and captured data.
1009         *
1010         * @return               An error code
1011         * @param[in]    flip                                            The camera flip type
1012         * @exception    E_SUCCESS                                       The method is successful.
1013         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
1014         * @exception    E_INVALID_ARG                           The input value is out of range.
1015         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
1016         * @exception    E_UNSUPPORTED_TYPE                The specified flip type is not supported.
1017         * @exception    E_SYSTEM                                        A system error has occurred.
1018         * @remarks              This method works in the ::CAMERA_STATE_INITIALIZED state.
1019         * @remarks              Finally the last specified type is applied even with the several types applicable.
1020         * @see            GetFlip()
1021         */
1022         result SetFlip(CameraFlipType flip);
1023
1024         /**
1025         * Gets the flip type for the previewed and captured data.
1026         *
1027         * @return               The Camera flip type
1028         * @exception    E_SUCCESS                               The method is successful.
1029         * @exception    E_INVALID_STATE                 This instance is in an invalid state for this method.
1030         * @see    SetFlip()
1031         */
1032         CameraFlipType GetFlip(void) const;
1033
1034         /**
1035         * Sets the rotation for the previewed data.
1036         *
1037         * @return                  An error code
1038         * @param[in] rotation                                                                     The camera rotation
1039         * @exception E_SUCCESS                                                     The method is successful.
1040         * @exception E_INVALID_STATE                                             This instance is in an invalid state for this method.
1041         * @exception E_INVALID_ARG                                      The input value is out of range.
1042         * @exception E_UNSUPPORTED_OPERATION     This operation is not supported.
1043         * @exception E_UNSUPPORTED_TYPE                    The specified rotation type is not supported.
1044         * @exception E_SYSTEM                                                           A system error has occurred.
1045         * @remarks   This method works in the ::CAMERA_STATE_INITIALIZED state.
1046         * @remarks   The last specified type is applied even with the several types applicable.
1047         * @remarks   This method rotates the preview and recording data but not the captured image. @n
1048         *                       The captured image's orientation is always following the physical rotation.
1049         * @remarks   When the preview is rotated, the preview callback data's width and height can be changed. @n
1050         *                       Thus the application should recognize these changes when it uses the preview data in ICameraEventListener::OnCameraPreviewed() callback.
1051         * @remarks   For the intended view of preview, Tizen::Ui::Controls::OverlayRegion::OVERLAY_REGION_TYPE_NORMAL should be selected when Tizen::Ui::Controls::OverlayRegion is created.
1052         * @see                                   GetPreviewRotation()
1053         *
1054         */
1055         result SetPreviewRotation(CameraRotation rotation);
1056
1057         /**
1058         *
1059         * Gets the rotation for the previewed data.
1060         *
1061         * @return                  The camera rotation
1062         * @exception E_SUCCESS                                          The method is successful.
1063         * @exception E_INVALID_STATE                              This instance is in an invalid state for this method.
1064         * @see                    SetPreviewRotation()
1065         *
1066         */
1067         CameraRotation GetPreviewRotation(void) const;
1068
1069         /**
1070         * Sets the metering mode of the camera.
1071         *
1072         * @return               An error code
1073         * @param[in]    meteringMode                            metering mode
1074         * @exception    E_SUCCESS                                       The method is successful.
1075         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
1076         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
1077         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
1078         * @exception    E_DEVICE_FAILED                         The device operation has failed.
1079         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
1080         * @exception    E_UNSUPPORTED_TYPE                The @c meteringMode type is not supported.
1081         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
1082         * @remarks      ::CAMERA_METERING_MODE_NONE always throws E_INVALID_ARG.
1083         * @see          GetMeteringMode()
1084         */
1085         result SetMeteringMode(CameraMeteringMode meteringMode);
1086
1087         /**
1088         * Gets the metering mode of the camera.
1089         *
1090         * @return               The %Camera metering mode
1091         * @see          SetMeteringMode()
1092         */
1093         CameraMeteringMode GetMeteringMode(void) const;
1094
1095         /**
1096          * Sets the scene mode of the camera.
1097          *
1098          * @return             An error code
1099          * @param[in]       sceneMode                                                  The scene mode
1100          * @exception       E_SUCCESS                                                               The method is successful.
1101          * @exception       E_INVALID_STATE                                         This instance is in an invalid state for this method.
1102          * @exception       E_DEVICE_BUSY                                            The camera is under use by other application.
1103          * @exception       E_DEVICE_UNAVAILABLE                  The camera becomes unavailable.
1104          * @exception       E_DEVICE_FAILED                                         The device operation has failed.
1105          * @exception       E_INVALID_ARG                                            The specified scene mode is invalid.
1106          * @exception       E_UNSUPPORTED_OPERATION         The target device does not support scene mode configuration feature.
1107          * @exception       E_UNSUPPORTED_TYPE                      The specified @c sceneMode is not supported.
1108          * @remarks             In a specific scene mode, camera's attributes such as brightness, metering mode, iso level, white balance, flash and focus  are changed to the ones which are pre-defined by each scene mode.@n
1109          *                         In a specific scene mode, if an application sets any attribute which is related to the scene, the mode can be changed to ::CAMERA_SCENE_OFF.@n
1110          *                         Thus it is recommended that the application checks the current scene mode after setting the attributes.@n
1111          *                         In case that the scene mode is changed to ::CAMERA_SCENE_OFF, all the attributes set by the application are re-loaded.@n
1112          */
1113          result SetSceneMode(CameraSceneMode sceneMode);
1114
1115          /**
1116          * Adds the stream filter to process the video stream data while previewing or recording.
1117          *
1118          * @return               An error code
1119          * @param[in]    filter                  An instance of IVideoStreamFilter
1120          * @exception    E_SUCCESS                       The method is successful.
1121          * @exception    E_OBJ_ALREADY_EXIST     The filter already exists.
1122          * @exception    E_OUT_OF_MEMORY         The memory is insufficient.
1123          * @remarks IVideoStreamFilter::ProcessVideoStream() will be called when the video frame is ready.
1124          */
1125          result AddVideoStreamFilter(IVideoStreamFilter& filter);
1126
1127          /**
1128          * Removes the stream filter to stop receiving the video stream data.
1129          *
1130          * @return               An error code
1131          * @param[in]    filter                  An instance of IVideoStreamFilter
1132          * @exception    E_SUCCESS                       The method is successful.
1133          * @exception    E_OBJ_NOT_FOUND                The filter is not found.
1134          */
1135          result RemoveVideoStreamFilter(IVideoStreamFilter& filter);
1136
1137          /**
1138          * Gets the scene mode of the camera.
1139          *
1140          * @return                         The %Camera scene mode
1141          */
1142          CameraSceneMode GetSceneMode(void) const;
1143
1144         /**
1145         * Gets the camera's state.
1146         *
1147         * @return                  The state
1148         */
1149         camera_state_e GetMmState(void) const;
1150
1151         /**
1152         * Sets the state.
1153         *
1154         * @param[in]    state                   _AudioRecorderImpl's state
1155         */
1156         void SetState(CameraState state);
1157
1158         /**
1159         * Get the camera selection.
1160         *
1161         * @return          The camera selection.
1162         */
1163         CameraSelection GetSelection(void) const;
1164
1165         /**
1166         * Enqueues the preview or captured data.
1167         *
1168         * @return          An error code
1169         * @exception    E_SUCCESS                                               The method is successful.
1170         * @exception    E_INVALID_ARG                   A specified input parameter is invalid.
1171         * @param[in]    cameraBuffer            The data prepared for enqueing.
1172         * @remarks      The preview and capture data is delivered by callback. _CameraImpl class should keep the data using Queue and consume the data in the event listener. @n
1173         *                       Preview frame skip is controled in this method.
1174         */
1175         result EnqueueData(_CameraBuffer& cameraBuffer);
1176
1177         /**
1178         * Dequeues the preview or captured data.
1179         *
1180         * @return          A buffer data
1181         * @param[in]    bufferType              The buffer type
1182         * @remarks      The preview and capture data is delivered by callback. _CameraImpl class should keep the data using Queue and consume the data in the event listener. @n
1183         *                       Preview frame skip is controled in this method. @n
1184         *                       The return value must be deleted. @n
1185         *                       The return value cannot be null.
1186         */
1187         _CameraBuffer* DequeueDataN(_CameraBufferType bufferType);
1188
1189         /**
1190         * Gets the camera coordinator.
1191         *
1192         * @return          camera coordinator
1193         */
1194         _CameraCoordinator* GetCoordinator(void);
1195
1196         /**
1197         * Gets the camera's zero shutter lag capability
1198         *
1199         * @return          Zero shutter lag capability
1200         */
1201         bool IsZeroShutterLag(void) const;
1202
1203
1204         /**
1205         * Gets the camera's recommened preview format
1206         *
1207         * @return          recommened preview format
1208         */
1209         Tizen::Graphics::PixelFormat GetDeviceRecommendPreviewFormat(void) const;
1210
1211         /**
1212         * Called when the event is received from the %_ICameraCoordinatorListener object.
1213         *
1214         * @return               An error code
1215         * @param[in]     message        message id
1216         * @param[in]     state          camera state
1217         * @param[in]     pParam0        Extra data0
1218         */
1219         result OnCamcorderCoordinatorEventReceived(camera_state_e previous, camera_state_e current, bool byPolicy);
1220
1221         /**
1222         * Called when the mode is prepared to change.
1223         *
1224         * @return               An error code
1225         * @param[in]     mode           camcorder mode
1226         */
1227         result OnCameraCoordinatorModeChangePrepared(_CameraMode mode);
1228
1229         /**
1230         * Called when the mode is changed.
1231         *
1232         * @return               An error code
1233         * @param[in]     mode           camcorder mode
1234         */
1235         result OnCameraCoordinatorModeChanged(_CameraMode mode);
1236
1237         /**
1238          *      Function definition for start capture.
1239          *
1240          *      @return         This function returns 0 on success, else on failure.
1241          *      @param[in]      mmHandle                The camcorder handle
1242          */
1243         static int StartMmCapture(_CameraHandle mmHandle);
1244
1245         /**
1246          *      Function definition for state chnaged callback.
1247          *
1248          *      @param[in]      previous                        Previous state
1249          *      @param[in]      current                 Current state
1250          *      @param[in]      byPolicy                        The flag which says the state was chnaged from the policy.
1251          *      @param[in]      pUserData               User parameter which is received from user when callback function was set
1252          *      @remarks        This function is called in the camera created thread.
1253          */
1254         static void StateChangedCb(camera_state_e previous, camera_state_e current, bool byPolicy, void *pUserData);
1255
1256         /**
1257          *      Function definition for image capture callback.
1258          *
1259          *      @param[in]      pImage                  Reference pointer to captured image data
1260          *      @param[in]      pPostview               Reference pointer to post view image data
1261          *      @param[in]      pThumbnail              Reference pointer to thumbnail data
1262          *      @param[in]      pUserData               User parameter which is received from user when callback function was set
1263          *      @remarks        This function is issued in the context of gstreamer (video src thread).
1264          */
1265         static void CaptureCb(camera_image_data_s* pImage, camera_image_data_s *pPostview, camera_image_data_s* pThumbnail, void* pUserData);
1266
1267         /**
1268          *      Function definition for capture completion callback.
1269          *
1270          *      @param[in]      pUserData               User parameter which is received from user when callback function was set
1271          *      @remarks        This function is issued in the context of gstreamer (video src thread).
1272          */
1273         static void CaptureCompletedCb(void *pUserData);
1274
1275         /**
1276          *      Function definition for preview stream callback.
1277          *
1278          *      @param[in]      pFrame                  frame data structure for stream
1279          *      @param[in]      pUserData                       User parameter which is received from user when callback function was set
1280          *      @remarks        This function is issued in the context of gstreamer (video src thread).
1281          */
1282         static void PreviewCb(camera_preview_data_s *pFrame, void *pUSerData);
1283
1284         /**
1285          *      Function definition for interrupted callback.
1286          *
1287          *      @param[in]      policy                  The policy which made the interruption
1288          *      @param[in]      previous                        Previous state
1289          *      @param[in]      current                 Current state
1290          *      @param[in]      pUserData               User parameter which is received from user when callback function was set
1291          *      @remarks        This function is called in the camera created thread.
1292          */
1293         static void InterruptedCb(camera_policy_e policy, camera_state_e previous, camera_state_e current, void *pUserData);
1294
1295
1296         /**
1297          *      Function definition for error callback.
1298          *
1299          *      @param[in]      error                   The cause which made the error
1300          *      @param[in]      current                 Current state
1301          *      @param[in]      pUserData               User parameter which is received from user when callback function was set
1302          *      @remarks        This function is called in the camera created thread.
1303          */
1304         static void ErrorCb(camera_error_e error, camera_state_e current, void *pUserData);
1305
1306         /**
1307          *      Function definition for focus changed callback.
1308          *
1309          *      @param[in]      state                   focus state
1310          *      @param[in]      pUserData               User parameter which is received from user when callback function was set
1311          *      @remarks        This function is called in the camera created thread.
1312          */
1313         static void FocusStateChangedCb(camera_focus_state_e state, void *pUserData);
1314
1315         /**
1316          *      Function check fo this object is alive.
1317          *
1318          * @return              true if the object is alive, otherwise false.
1319          */
1320         static bool IsAlive(void);
1321
1322         /**
1323          * Gets the Impl instance.
1324          *
1325          * @return              The pointer to %_CameraImpl
1326          * @param[in]   pCamera         The %Camera pointer
1327          */
1328         static _CameraImpl* GetInstance(Camera *pCamera);
1329
1330         /**
1331          * Gets the Impl instance.
1332          *
1333          * @return              The pointer to %_CameraImpl
1334          * @param[in]   pCamera         The %Camera pointer
1335          */
1336         static const _CameraImpl* GetInstance(const Camera *pCamera);
1337
1338 private:
1339         /**
1340         * Converts the error from camera.
1341         *
1342         * @return          An error code
1343         * @param[in]    err                      camera error
1344         */
1345         result ConvertResult(int err) const;
1346
1347         /**
1348         * Set the property.
1349         *
1350         * @return          An error code
1351         * @param[in]    operation                  camcorder's operation type
1352         * @param[in]    min                                      min value
1353         * @param[in]    max                              max value
1354         * @param[in]    value                      value to be set
1355         */
1356         result SetProperty(_CameraOperationType operation, int min, int max, int value);
1357
1358         /**
1359         * Get the property.
1360         *
1361         * @return          An error code
1362         * @param[in]    operation                  camcorder's operation type
1363         * @param[out]   mmMin                              min value
1364         * @param[out]   mmMax                      max value
1365         */
1366         result GetProperty(_CameraOperationType operation, int& mmMin, int& mmMax) const;
1367
1368         /**
1369         * Get the property list.
1370         *
1371         * @return          The property list
1372         * @param[in]    operation                  camcorder's operation type
1373         * @param[in]    itemQueryType      item type for verifying the list
1374         * @remarks      If the list's item type and itemQueryType parameter are not same, it returns null.
1375         */
1376         Tizen::Base::Collection::IList* GetPropertyListN(_CameraOperationType operation, _ResultType itemQueryType) const;
1377
1378         /**
1379         * Get the property list.
1380         *
1381         * @return          The property list
1382         * @param[in]    key                key name
1383         */
1384         Tizen::Base::Collection::IList* GetPropertyListN(const Tizen::Base::String& key) const;
1385
1386         /**
1387         * Re-load configuration.
1388         *
1389         * @return          An error code
1390         * @param[in]    reload                            reload configuration field
1391         * @exception    E_SUCCESS                               The method is successful.
1392         * @exception    E_SYSTEM                                A system error has occurred.
1393         * @remarks      Multiple configuration field can be set using reloadConf parameter appending.
1394         */
1395         result ReloadConfiguration(int reload);
1396
1397         /**
1398         * Load default configuration.
1399         *
1400         * @return          An error code
1401         * @param[in]    reload                            reload configuration field
1402         * @exception    E_SUCCESS                               The method is successful.
1403         * @exception    E_SYSTEM                                A system error has occurred.
1404         */
1405         result LoadDefaultConfiguration(int reload);
1406
1407         /**
1408         * Change the focus state.
1409         *
1410         * @return       An error code
1411         * @param[in]    currentMode             focus' current mode
1412         * @param[in]    destMode             focus' destinationed mode
1413         * @exception    E_SUCCESS                               The method is successful.
1414         * @exception    E_SYSTEM                                A system error has occurred.
1415         */
1416         result ChangeFocusModeTo(CameraFocusMode currentMode, CameraFocusMode destMode);
1417
1418         /**
1419         * Handle the auto focus operations.
1420         *
1421         * @return       An error code
1422         * @param[in]    currentMode             focus' current mode
1423         * @exception    E_SUCCESS                               The method is successful.
1424         * @exception    E_SYSTEM                                A system error has occurred.
1425         */
1426         result HandleAutoFocus(CameraFocusMode currentMode);
1427
1428         /**
1429          * Sets the scene mode of the camera internally.
1430          *
1431          * @return             An error code
1432          * @param[in]       sceneMode                                                  The scene mode
1433          * @exception       E_SUCCESS                                                               The method is successful.
1434          * @exception       E_DEVICE_FAILED                                         The device operation has failed.
1435          * @exception   E_SYSTEM                                A system error has occurred.
1436          */
1437         result SetSceneModeAttr(CameraSceneMode sceneMode);
1438
1439         _CameraImpl(const _CameraImpl& camera);
1440         _CameraImpl& operator =(const _CameraImpl& camera);
1441
1442         _CameraDeviceType __deviceType;
1443         _CameraCoordinator* __pCoordinator;
1444         _CameraCapability* __pCameraCapability;
1445
1446         CameraState __state;
1447         _CameraHandle __handle;
1448
1449         std::unique_ptr <_CameraEvent> __pCameraEvent;
1450         std::unique_ptr <_VideoStreamCoordinator> __pVideoStreamCoordinator;
1451         ICameraEventListener* __pCameraEventListener;
1452         std::unique_ptr <Tizen::Base::Collection::Queue, _ListPtrUtil::Remover> __pCaptureBufferQueue;
1453         std::unique_ptr <Tizen::Base::Collection::Queue, _ListPtrUtil::Remover> __pPreviewBufferQueue;
1454
1455         bool __isConstructed;
1456         bool __isPoweredOn;
1457         CameraSelection __selection;
1458         int __brightness;
1459         int __contrast;
1460         int __exposure;
1461         int __zoomLevel;
1462         int __minZoomLevel;
1463         int __maxZoomLevel;
1464         CameraEffect __effect;
1465         CameraWhiteBalance __wb;
1466         CameraQuality __quality;
1467         CameraIsoLevel __isoLevel;
1468         CameraFlashMode __flashMode;
1469         bool __zeroShutterLag;
1470         CameraMeteringMode __meteringMode;
1471         CameraSceneMode __sceneMode;
1472         bool __focusCallback;
1473         bool __isFocusAreaSet;
1474
1475         Tizen::Graphics::Dimension __previewResolution;
1476         Tizen::Graphics::Dimension __deviceDefaultPreviewResolution;    // device default
1477         Tizen::Graphics::Dimension __captureResolution;
1478         Tizen::Graphics::Dimension __deviceDefaultCaptureResolution;    // device default
1479
1480         Tizen::Graphics::PixelFormat __previewFormat;
1481         Tizen::Graphics::PixelFormat __deviceDefaultPreviewFormat;              // device default
1482         Tizen::Graphics::PixelFormat __captureFormat;
1483         Tizen::Graphics::PixelFormat __deviceDefaultCaptureFormat;              // device default
1484
1485         CameraExifOrientation __exifOrientation;
1486         static const CameraExifOrientation CAMERA_EXIF_ORIENTATION_NONE = (CameraExifOrientation)-1;
1487         double __exifLatitude;
1488         double __exifLongitude;
1489         float   __exifAltitude;
1490
1491         CameraFlipType __flip;
1492         CameraRotation __previewRotation;
1493         int __fps;
1494         CameraFocusMode __focusMode;
1495
1496         int __previewProcessing;
1497         Tizen::Graphics::Rectangle __previewRegionRect;
1498         int __previewRegionHandle;
1499         camera_display_type_e __previewDisplayType;
1500         CameraRotation __displayRotationType;
1501         CameraDirection __physicalDirection;
1502         CameraRotation __physicalRotation;
1503         static const int MAX_FOCUS_POINT = 10;
1504         int __focusPoints[2][MAX_FOCUS_POINT];
1505         int __supportedFocusPointCount;
1506
1507         static bool __isUsed;
1508         static const int MAX_CAMERA_PLANE_COUNT = 4;
1509 };
1510
1511 }}// Tizen::Media
1512
1513 #endif