src/FMedia_CameraImpl.cpp

   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.cpp
  20  * @brief                       This file contains the implementation of the %_CameraImpl class.
  21  *
  22  */
  23
  24 #include <unique_ptr.h>
  25 #include <Evas.h>
  26 #include <FBaseInteger.h>
  27 #include <FBaseSysLog.h>
  28 #include <FBaseColArrayList.h>
  29 #include <FGrpDimension.h>
  30 #include <FGrpPoint.h>
  31 #include <FGrp_BufferInfoImpl.h>
  32 #include <FMediaTypes.h>
  33 #include <FMediaImageTypes.h>
  34 #include <FMediaCamera.h>
  35 #include <FMediaICameraEventListener.h>
  36 #include <FMediaCapabilityTypes.h>
  37 #include <FMediaIVideoStreamFilter.h>
  38 #include "FMedia_CameraImpl.h"
  39 #include "FMedia_CameraEvent.h"
  40 #include "FMedia_CameraUtil.h"
  41 #include "FMedia_CameraCapability.h"
  42 #include "FMedia_CameraCoordinator.h"
  43 #include "FMedia_CapabilityImpl.h"
  44 #include "FMedia_VideoStreamCoordinator.h"
  45
  46 #define _CAMERA_EVAS_PIXMAP_ 1
  47
  48 using namespace Tizen::Base;
  49 using namespace Tizen::Base::Collection;
  50 using namespace Tizen::Graphics;
  51
  52 namespace Tizen { namespace Media
  53 {
  54 static const int _RELOAD_BRIGHTNESS = 0x1;
  55 static const int _RELOAD_CONTRAST = 0x1 << 1;
  56 static const int _RELOAD_EXPOSURE = 0x1 << 2;
  57 static const int _RELOAD_MAX_ZOOM_LEVEL = 0x1 << 3;
  58 static const int _RELOAD_ZOOM_LEVEL = 0x1 << 4;
  59 static const int _RELOAD_PREVIEW_RESOLUTION = 0x1 << 5;
  60 static const int _RELOAD_CAPTURE_RESOLUTION = 0x1 << 6;
  61 static const int _RELOAD_PREVIEW_FORMAT = 0x1 << 7;
  62 static const int _RELOAD_CAPTURE_FORMAT = 0x1 << 8;
  63 static const int _RELOAD_EFFECT = 0x1 << 9;
  64 static const int _RELOAD_WB = 0x1 << 10;
  65 static const int _RELOAD_QUALITY = 0x1 << 11;
  66 static const int _RELOAD_ISO = 0x1 << 12;
  67 static const int _RELOAD_FLASH = 0x1 << 13;
  68 static const int _RELOAD_EXIF_ORIENTATION = 0x1 << 14;
  69 static const int _RELOAD_EXIF_GPS_COORDINATES = 0x1 << 15;
  70 static const int _RELOAD_FLIP = 0x1 << 16;
  71 static const int _RELOAD_PREVIEW_ROTATION = 0x1 << 17;
  72 static const int _RELOAD_FPS = 0x1 << 18;
  73 static const int _RELOAD_PREVIEW_PREPARE = 0x1 << 19;
  74 static const int _RELOAD_INTERNAL_PREVIEW_FORMAT = 0x1 << 20;
  75 static const int _RELOAD_FOCUS_MODE = 0x1 << 21;
  76 static const int _RELOAD_ZERO_SHUTTER_LAG = 0x1 << 22;
  77 static const int _RELOAD_METERING_MODE = 0x1 << 23;
  78 static const int _RELOAD_SCENE_MODE = 0x1 << 24;
  79 static const int _RELOAD_EXTRA = 0x1 << 25;
  80
  81 static const int _PREVIEW_PRE_PROCESSING = 0x01;
  82 static const int _PREVIEW_POST_PROCESSING = 0x01 << 1;
  83
  84 static const double _CAMERA_EXIF_GPS_INVALID_LATITUDE = 90.1;
  85 static const double _CAMERA_EXIF_GPS_INVALID_LONGITUDE = 180.1;
  86
  87 static const int _MAX_CAPTURE_BUFFER_COUNT = 10;
  88 static const int _MAX_PREVIEW_BUFFER_COUNT = 1;
  89 static const int _MIN_PROPERTY = 0;
  90 static const int _MAX_PROPERTY = 9;
  91 static const int _INVALID_FOCUS_COORDINATE = -1;
  92
  93 bool _CameraImpl::__isUsed = false;
  94
  95 enum _FocusModeOperation
  96 {
  97         _FOCUS_MODE_OP_NONE,
  98         _FOCUS_MODE_OP_CONTINUOUS,
  99         _FOCUS_MODE_OP_CANCEL,
 100 };
 101
 102 typedef struct
 103 {
 104         CameraFocusMode currentMode;
 105         _FocusModeOperation focusOperation0;
 106         CameraFocusMode destMode;
 107         _FocusModeOperation focusOperation1;
 108 } _CameraFocusModeTransitTable;
 109
 110 static const _CameraFocusModeTransitTable _CAMERA_FOCUS_MODE_TRANSIT[] =
 111 {
 112         {CAMERA_FOCUS_MODE_NONE,                        _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_NONE,                         _FOCUS_MODE_OP_NONE},
 113         {CAMERA_FOCUS_MODE_NONE,                        _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_NORMAL,                       _FOCUS_MODE_OP_NONE},
 114         {CAMERA_FOCUS_MODE_NONE,                        _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_MACRO,                        _FOCUS_MODE_OP_NONE},
 115         {CAMERA_FOCUS_MODE_NONE,                        _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,              _FOCUS_MODE_OP_CONTINUOUS},
 116         {CAMERA_FOCUS_MODE_NONE,                        _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_INFINITE,                     _FOCUS_MODE_OP_NONE},
 117
 118         {CAMERA_FOCUS_MODE_NORMAL,                      _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_NONE,                 _FOCUS_MODE_OP_NONE},
 119         {CAMERA_FOCUS_MODE_NORMAL,                      _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_NORMAL,                       _FOCUS_MODE_OP_NONE},
 120         {CAMERA_FOCUS_MODE_NORMAL,                      _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_MACRO,                        _FOCUS_MODE_OP_NONE},
 121         {CAMERA_FOCUS_MODE_NORMAL,                      _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,              _FOCUS_MODE_OP_CONTINUOUS},
 122         {CAMERA_FOCUS_MODE_NORMAL,                      _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_INFINITE,                     _FOCUS_MODE_OP_NONE},
 123
 124         {CAMERA_FOCUS_MODE_MACRO,                       _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_NONE,                 _FOCUS_MODE_OP_NONE},
 125         {CAMERA_FOCUS_MODE_MACRO,                       _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_NORMAL,                       _FOCUS_MODE_OP_NONE},
 126         {CAMERA_FOCUS_MODE_MACRO,                       _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_MACRO,                        _FOCUS_MODE_OP_NONE},
 127         {CAMERA_FOCUS_MODE_MACRO,                       _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,              _FOCUS_MODE_OP_CONTINUOUS},
 128         {CAMERA_FOCUS_MODE_MACRO,                       _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_INFINITE,                     _FOCUS_MODE_OP_NONE},
 129
 130         {CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,             _FOCUS_MODE_OP_CANCEL,          CAMERA_FOCUS_MODE_NONE,                 _FOCUS_MODE_OP_NONE},
 131         {CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,             _FOCUS_MODE_OP_CANCEL,          CAMERA_FOCUS_MODE_NORMAL,                       _FOCUS_MODE_OP_NONE},
 132         {CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,             _FOCUS_MODE_OP_CANCEL,          CAMERA_FOCUS_MODE_MACRO,                        _FOCUS_MODE_OP_NONE},
 133         {CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,             _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,              _FOCUS_MODE_OP_NONE},
 134         {CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,             _FOCUS_MODE_OP_CANCEL,          CAMERA_FOCUS_MODE_INFINITE,                     _FOCUS_MODE_OP_NONE},
 135
 136         {CAMERA_FOCUS_MODE_INFINITE,                    _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_NONE,                 _FOCUS_MODE_OP_NONE},
 137         {CAMERA_FOCUS_MODE_INFINITE,                    _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_NORMAL,                       _FOCUS_MODE_OP_NONE},
 138         {CAMERA_FOCUS_MODE_INFINITE,                    _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_MACRO,                        _FOCUS_MODE_OP_NONE},
 139         {CAMERA_FOCUS_MODE_INFINITE,                    _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,              _FOCUS_MODE_OP_CONTINUOUS},
 140         {CAMERA_FOCUS_MODE_INFINITE,                    _FOCUS_MODE_OP_NONE,            CAMERA_FOCUS_MODE_INFINITE,                     _FOCUS_MODE_OP_NONE},
 141 };
 142
 143 enum _FocusOperation
 144 {
 145         _FOCUS_OP_NONE,
 146         _FOCUS_OP_ONCE,
 147 };
 148
 149 typedef struct
 150 {
 151         CameraFocusMode currentMode;
 152         _FocusOperation focusOperation;
 153         CameraState state;
 154 } _CameraFocusOperationTable;
 155
 156 static const _CameraFocusOperationTable _CAMERA_FOCUS_OPERATIONT[] =
 157 {
 158 //      {CAMERA_FOCUS_MODE_NONE,                        _FOCUS_OP_NONE,         (CameraState)-1,},
 159         {CAMERA_FOCUS_MODE_NORMAL,                      _FOCUS_OP_ONCE,         CAMERA_STATE_AUTO_FOCUSING,},
 160         {CAMERA_FOCUS_MODE_MACRO,                       _FOCUS_OP_ONCE,         CAMERA_STATE_AUTO_FOCUSING,},
 161         {CAMERA_FOCUS_MODE_CONTINUOUS_AUTO,_FOCUS_OP_NONE,              (CameraState)-1,},              //no state change in the continuous mode
 162 //      {CAMERA_FOCUS_MODE_INFINITE,                    _FOCUS_OP_NONE,         (CameraState)-1,},
 163 };
 164
 165 _CameraImpl::_CameraImpl(void)
 166         : __deviceType(_CAMERA_DEVICE_NONE)
 167         , __pCoordinator(null)
 168         , __pCameraCapability(null)
 169         , __state(CAMERA_STATE_INITIALIZED)
 170         , __handle(MM_INVALID_HANDLE)
 171         , __pCameraEvent(null)
 172         , __pVideoStreamCoordinator(null)
 173         , __pCameraEventListener(null)
 174         , __pCaptureBufferQueue(null, _ListPtrUtil::remover)
 175         , __pPreviewBufferQueue(null, _ListPtrUtil::remover)
 176         , __isConstructed(false)
 177         , __isPoweredOn(false)
 178         , __selection(CAMERA_PRIMARY)
 179         , __brightness(DEFAULT_CAMERA_BRIGHTNESS)
 180         , __contrast(DEFAULT_CAMERA_CONTRAST)
 181         , __exposure(DEFAULT_CAMERA_EXPOSURE)
 182         , __zoomLevel(0)
 183         , __minZoomLevel(0)
 184         , __maxZoomLevel(0)
 185         , __effect(CAMERA_EFFECT_NONE)
 186         , __wb(CAMERA_WHITE_BALANCE_AUTO )
 187         , __quality(CAMERA_QUALITY_NORMAL)
 188         , __isoLevel(CAMERA_ISO_DEFAULT)
 189         , __flashMode(CAMERA_FLASH_MODE_OFF)
 190         , __zeroShutterLag(false)
 191         , __meteringMode(CAMERA_METERING_MODE_NONE)
 192         , __sceneMode(CAMERA_SCENE_OFF)
 193         , __focusCallback(false)
 194         , __isFocusAreaSet(false)
 195         , __exifOrientation(CAMERA_EXIF_ORIENTATION_NONE)
 196         , __exifLatitude(_CAMERA_EXIF_GPS_INVALID_LATITUDE)
 197         , __exifLongitude(_CAMERA_EXIF_GPS_INVALID_LONGITUDE)
 198         , __exifAltitude(0)
 199         , __flip(CAMERA_FLIP_NONE)
 200         , __previewRotation(CAMERA_ROTATION_NONE)
 201 #if defined(_OSP_EMUL_)
 202         , __fps(30)
 203 #else
 204         , __fps(DEFAULT_CAMERA_PREVIEW_FPS)
 205 #endif
 206         , __focusMode(CAMERA_FOCUS_MODE_NONE)
 207         , __previewProcessing(0)
 208         , __previewRegionHandle(_BufferInfoImpl::INVALID_BUFFER_HANDLE)
 209         , __previewDisplayType(::CAMERA_DISPLAY_TYPE_NONE)
 210         , __displayRotationType(CAMERA_ROTATION_NONE)
 211         , __physicalDirection(CAMERA_DIRECTION_BACK)
 212         , __physicalRotation(CAMERA_ROTATION_NONE)
 213         , __supportedFocusPointCount(0)
 214 {
 215         __previewResolution.width = 0;
 216         __previewResolution.height = 0;
 217         __deviceDefaultPreviewResolution.width = 0;
 218         __deviceDefaultPreviewResolution.height = 0;
 219
 220         __captureResolution.width = 0;
 221         __captureResolution.height = 0;
 222         __deviceDefaultCaptureResolution.width = 0;
 223         __deviceDefaultCaptureResolution.height = 0;
 224
 225         __previewFormat = PIXEL_FORMAT_YCbCr420_PLANAR;
 226         __deviceDefaultPreviewFormat = PIXEL_FORMAT_YCbCr420_PLANAR;
 227
 228         __captureFormat = PIXEL_FORMAT_JPEG;
 229         __deviceDefaultCaptureFormat = PIXEL_FORMAT_JPEG;
 230
 231         for(int i = 0; i < MAX_FOCUS_POINT; i++)
 232         {
 233                 __focusPoints[0][i] = _INVALID_FOCUS_COORDINATE;
 234                 __focusPoints[1][i] = _INVALID_FOCUS_COORDINATE;
 235         }
 236 }
 237
 238 _CameraImpl::~_CameraImpl(void)
 239 {
 240         if (__handle != MM_INVALID_HANDLE)
 241         {
 242                 int err = MM_SUCCESS;
 243                 err = camera_unset_state_changed_cb(__handle);
 244                 err = camera_unset_interrupted_cb(__handle);
 245                 err = camera_unset_error_cb(__handle);
 246                 err = camera_unset_focus_changed_cb(__handle);
 247                 err = camera_unset_preview_cb(__handle);
 248                 __handle = MM_INVALID_HANDLE;
 249         }
 250         if (__pCoordinator != null)
 251         {
 252                 __pCoordinator->RemoveCameraCoordinatorListener(*this);
 253
 254                 if (IsPoweredOn())
 255                 {
 256                         PowerOff();
 257                 }
 258
 259                 _CameraCoordinator::Release(__deviceType);
 260         }
 261
 262         if (__pCameraCapability != null)
 263         {
 264                 _CameraCapability::Release(__deviceType);
 265         }
 266
 267         if ( __isConstructed )
 268         {
 269                 __isUsed = false;
 270         }
 271
 272         SysLog(NID_MEDIA, "Destroyed");
 273 }
 274
 275 result
 276 _CameraImpl::Construct(ICameraEventListener& listener, CameraSelection camSel)
 277 {
 278         result r = E_SUCCESS;
 279         int err = MM_SUCCESS;
 280         SysLog(NID_MEDIA, "Enter. camSel:%d", camSel);
 281
 282         SysTryReturn(NID_MEDIA, !__isUsed, E_DEVICE_BUSY, E_DEVICE_BUSY, "[E_DEVICE_BUSY] A camera device is already used.");
 283         SysTryReturn(NID_MEDIA, !__isConstructed, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] _CameraImpl is in an invalid state. A camera device is already constructed.");
 284         SysTryReturn(NID_MEDIA, camSel >= CAMERA_PRIMARY && camSel <= CAMERA_SECONDARY, E_DEVICE_UNAVAILABLE, E_DEVICE_UNAVAILABLE, "[E_DEVICE_UNAVAILABLE] The camsel(%d)  is invalid.", camSel);
 285
 286         // _CapablityImpl object should be created before the camera_create() is called to get the recorder capability without problem. camera c-api.
 287         // _CapabilityImpl is not deleted until the application exits.
 288         int cameraCount = 0;
 289         _CapabilityImpl* pCapabilityImpl = _CapabilityImpl::GetInstance();
 290         SysTryReturn(NID_MEDIA, pCapabilityImpl != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. Capability is not obtained.");
 291
 292         r = pCapabilityImpl->GetValue(L"Camera.Count", cameraCount);
 293         SysTryReturn(NID_MEDIA, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. Number of Camera was not obtained.");
 294         SysTryReturn(NID_MEDIA, camSel < cameraCount, E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The camSel(%d)  is not available.", camSel);
 295         __selection = camSel;
 296
 297         // Get the _CameraCapability.
 298         // This is just for the performance enhancement by incrementing ref counts of _CameraCapability.
 299         // It forbiddens creating and deleting the _CameraCapability object repeatedly.
 300         __deviceType = (camSel == CAMERA_PRIMARY ? _CAMERA_DEVICE_PRIMARY : _CAMERA_DEVICE_SECONDARY);
 301         __pCameraCapability = _CameraCapability::AddInstance(__deviceType);
 302         SysTryReturn(NID_MEDIA, __pCameraCapability != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Capability instance is not available.");
 303
 304         int direction = 0;
 305         int rotation = 0;
 306         int focusPoint = 0;
 307         r = pCapabilityImpl->GetValue(camSel == CAMERA_PRIMARY ? String(L"Camera.Primary.Direction") : String(L"Camera.Secondary.Direction"), direction);
 308         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 309
 310         r = pCapabilityImpl->GetValue(camSel == CAMERA_PRIMARY ? String(L"Camera.Primary.Rotation") : String(L"Camera.Secondary.Rotation"), rotation);
 311         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 312
 313         __physicalDirection = static_cast<CameraDirection>(direction);
 314         __physicalRotation = static_cast<CameraRotation>(rotation);
 315
 316         r = pCapabilityImpl->GetValue(camSel == CAMERA_PRIMARY ? String(L"Camera.Primary.FocusPoint") : String(L"Camera.Secondary.FocusPoint"), focusPoint);
 317         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 318         __supportedFocusPointCount = focusPoint;
 319
 320 // Create Event
 321         __pCameraEvent.reset(new (std::nothrow) _CameraEvent());
 322         SysTryReturn(NID_MEDIA, __pCameraEvent.get() != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 323
 324         r = __pCameraEvent->Construct(*this);
 325         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 326
 327         r = __pCameraEvent->AddListener(listener);
 328         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 329         __pCameraEventListener = &listener;
 330
 331 // Video stream coordinator
 332         __pVideoStreamCoordinator.reset(new (std::nothrow) _VideoStreamCoordinator());
 333         SysTryReturn(NID_MEDIA, __pVideoStreamCoordinator.get() != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 334
 335         r = __pVideoStreamCoordinator->Construct();
 336         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 337
 338 // Prepare captured buffer list
 339         __pCaptureBufferQueue.reset(new (std::nothrow) Tizen::Base::Collection::Queue());
 340         SysTryCatch(NID_MEDIA, __pCaptureBufferQueue.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 341
 342         r = __pCaptureBufferQueue->Construct(_MAX_CAPTURE_BUFFER_COUNT);         // For async panorama shot.
 343         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 344
 345 // Prepare preview buffer list
 346         __pPreviewBufferQueue.reset(new (std::nothrow) Tizen::Base::Collection::Queue());
 347         SysTryCatch(NID_MEDIA, __pPreviewBufferQueue.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 348
 349         r = __pPreviewBufferQueue->Construct(_MAX_PREVIEW_BUFFER_COUNT);         // For async preview data.
 350         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 351
 352         // Get the _CameraCoordinator
 353         __pCoordinator = _CameraCoordinator::AddInstance(__deviceType);
 354         r = GetLastResult();
 355         // To do : return should be checked. (E_DEVICE_UNAVAILABLE or E_DEVICE_BUSY)
 356         SysTryCatch(NID_MEDIA, __pCoordinator != null, , r, "[E_OBJ_NOT_FOUND] _CameraCoordinator instance is not available.");
 357
 358         // Add this to _CameraCoordinator
 359         r = __pCoordinator->AddCameraCoordinatorListener(*this);
 360         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 361
 362         __handle = __pCoordinator->GetCameraHandle();
 363
 364         err = camera_set_state_changed_cb(__handle, StateChangedCb, this);
 365         r = ConvertResult(err);
 366         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 367
 368         err = camera_set_interrupted_cb(__handle, InterruptedCb, this);
 369         r = ConvertResult(err);
 370         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 371
 372         err = camera_set_error_cb(__handle, ErrorCb, this);
 373         r = ConvertResult(err);
 374         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 375
 376         err = camera_set_focus_changed_cb(__handle, FocusStateChangedCb, this);
 377         r = ConvertResult(err);
 378         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to set the focus changed callback.", GetErrorMessage(r));
 379
 380         // Get the default properties
 381         r = LoadDefaultConfiguration(_RELOAD_PREVIEW_RESOLUTION | _RELOAD_CAPTURE_RESOLUTION | _RELOAD_PREVIEW_FORMAT | _RELOAD_CAPTURE_FORMAT
 382                                                         | _RELOAD_FOCUS_MODE |_RELOAD_ZERO_SHUTTER_LAG | _RELOAD_METERING_MODE);
 383         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 384
 385         SetState(CAMERA_STATE_INITIALIZED);
 386         __isConstructed = true;
 387         __isUsed = true;
 388         return r;
 389
 390 CATCH:
 391         if (__handle)
 392         {
 393                 err = camera_unset_state_changed_cb(__handle);
 394                 err = camera_unset_interrupted_cb(__handle);
 395                 err = camera_unset_error_cb(__handle);
 396                 err = camera_unset_focus_changed_cb(__handle);
 397         }
 398
 399         if (__pCoordinator != null)
 400         {
 401                 __pCoordinator->RemoveCameraCoordinatorListener(*this);
 402         }
 403
 404         if (__pCameraEventListener != null)
 405         {
 406                 __pCameraEvent->RemoveListener(*__pCameraEventListener);
 407                 __pCameraEventListener = null;
 408         }
 409
 410         __pCameraEvent.reset(null);
 411         __pVideoStreamCoordinator.reset(null);
 412         __pCaptureBufferQueue.reset(null);
 413
 414         return r;
 415 }
 416
 417 result
 418 _CameraImpl::PowerOn(void)
 419 {
 420         result r = E_SUCCESS;
 421         CameraState state = CAMERA_STATE_ERROR;
 422         int err = MM_SUCCESS;
 423         SysLog(NID_MEDIA, "Camera powerON");
 424
 425         SysTryReturn(NID_MEDIA, __isPoweredOn == false, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was already powered on.");
 426
 427         state = GetState();
 428         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state(%d), Camera is not in initialized state.", state);
 429
 430         __isPoweredOn = true;
 431
 432         err = camera_set_display(__handle, ::CAMERA_DISPLAY_TYPE_NONE, null);
 433         r = ConvertResult(err);
 434         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Temporarily forbidden the preview callback.", GetErrorMessage(r));
 435
 436         // re-configuration for new camera handle. active conf.
 437         if (__sceneMode == CAMERA_SCENE_OFF)
 438         {
 439                 r = ReloadConfiguration(_RELOAD_BRIGHTNESS  | _RELOAD_WB  |  _RELOAD_ISO  | _RELOAD_METERING_MODE | _RELOAD_FLASH);
 440                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera reload configuration failed", GetErrorMessage(r));
 441         }
 442
 443         r = ReloadConfiguration(_RELOAD_CONTRAST  | _RELOAD_EXPOSURE  | _RELOAD_MAX_ZOOM_LEVEL
 444                                                         | _RELOAD_PREVIEW_RESOLUTION  | _RELOAD_CAPTURE_RESOLUTION  | _RELOAD_PREVIEW_FORMAT
 445                                                         | _RELOAD_CAPTURE_FORMAT  | _RELOAD_FPS  | _RELOAD_EFFECT  | _RELOAD_QUALITY
 446                                                         | _RELOAD_EXIF_ORIENTATION  | _RELOAD_EXIF_GPS_COORDINATES
 447                                                         | _RELOAD_FLIP  | _RELOAD_PREVIEW_ROTATION | _RELOAD_SCENE_MODE
 448                                                         | _RELOAD_EXTRA);
 449         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera reload configuration failed", GetErrorMessage(r));
 450         return r;
 451
 452 CATCH:
 453         __isPoweredOn = false;
 454         return r;
 455 }
 456
 457 result
 458 _CameraImpl::PowerOff(void)
 459 {
 460         result r = E_SUCCESS;
 461         camera_state_e mmState = ::CAMERA_STATE_NONE;
 462         SysLog(NID_MEDIA, "Camera powerOFF");
 463
 464         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
 465
 466         mmState = GetMmState();
 467         switch (mmState)
 468         {
 469         case ::CAMERA_STATE_PREVIEW:
 470                 r = __pCoordinator->StopMmPreview();
 471                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 472                 break;
 473
 474         case ::CAMERA_STATE_CAPTURING:
 475                 // Camera's destroy while capturing should be done by waiting until the state is changed to CAPTURED..
 476                 {
 477                         const int timeoutCount = 100;
 478                         const long sleepTime = 50;
 479                         int i = 0;
 480                         while (GetMmState() == ::CAMERA_STATE_CAPTURING && ( i++ <  timeoutCount) )
 481                         {
 482                                 r = Tizen::Base::Runtime::Thread::Sleep(sleepTime);
 483                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_DEVICE_FAILED, E_DEVICE_FAILED, "[E_DEVICE_FAILED] Sleep failed while waiting the state changing to CAPTURED.");
 484                                 SysLog(NID_MEDIA, "Sleep try %dst", i);
 485                         }
 486                         SysTryCatch(NID_MEDIA, i < timeoutCount, r = E_DEVICE_BUSY, E_DEVICE_BUSY, "[E_DEVICE_BUSY] Sleep failed while waiting the state changing to CAPTURED.");
 487                         SysLog(NID_MEDIA, "PowerOff succeeded from capturing state in %d msec.", (int)sleepTime*i);
 488
 489                         mmState = GetMmState();
 490                         // The captured buffer inserted via CaptureCb should be deleted.
 491                         ByteBuffer* pBuffer = null;
 492                         while ((pBuffer = DequeueDataN(_CAMERA_BUFFER_CAPTURE)) != null)
 493                         {
 494                                 delete pBuffer;
 495                                 pBuffer = null;
 496                         }
 497                 }
 498                 //The state is changed synchronously
 499                 SetState(CAMERA_STATE_CAPTURED);
 500
 501                 r = __pCoordinator->StartMmPreview();
 502                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 503
 504                 r = __pCoordinator->StopMmPreview();
 505                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 506                 break;
 507
 508         case ::CAMERA_STATE_CAPTURED:
 509                 r = __pCoordinator->StartMmPreview();
 510                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 511
 512                 r = __pCoordinator->StopMmPreview();
 513                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 514                 break;
 515
 516         case ::CAMERA_STATE_CREATED:
 517                 //fall through
 518         case ::CAMERA_STATE_NONE:
 519                 break;
 520
 521         default:
 522                 SysLogException(NID_MEDIA, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. mmState:%d", mmState);
 523                 goto CATCH;
 524                 break;
 525         }
 526
 527         __isPoweredOn = false;
 528         __zoomLevel = 0;
 529         SetState(CAMERA_STATE_INITIALIZED);
 530         return r;
 531
 532 CATCH:
 533         return r;
 534 }
 535
 536 bool
 537 _CameraImpl::IsPoweredOn(void) const
 538 {
 539         return __isPoweredOn;
 540 }
 541
 542 result
 543 _CameraImpl::StartPreview(const Tizen::Graphics::BufferInfo* pBufferInfo, bool previewedData)
 544 {
 545         result r = E_SUCCESS;
 546         int err = MM_SUCCESS;
 547         camera_state_e mmState = ::CAMERA_STATE_NONE;
 548         CameraState state = CAMERA_STATE_ERROR;
 549         Rectangle tempDisplayRect;
 550         int tempDisplayHandle = _BufferInfoImpl::INVALID_BUFFER_HANDLE;
 551         CameraRotation tempDisplayRotationType = CAMERA_ROTATION_NONE;
 552         camera_display_type_e tempDisplayType = ::CAMERA_DISPLAY_TYPE_NONE;
 553
 554         SysLog(NID_MEDIA, "Camera StartPreview. pBufferInfo:%d, previewedData:%d", (int) pBufferInfo, previewedData);
 555         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on");
 556
 557         state = GetState();
 558         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_CAPTURED
 559                            , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera state[%d] is not ready to start preview.", state);
 560
 561         // Set preview callback
 562         if (previewedData || (__previewProcessing & _PREVIEW_PRE_PROCESSING))
 563         {
 564                 err = camera_set_preview_cb(__handle, PreviewCb, this);
 565         }
 566         else
 567         {
 568                 err = camera_unset_preview_cb(__handle);
 569         }
 570         r = ConvertResult(err);
 571         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 572
 573         mmState = GetMmState();
 574
 575         if ( pBufferInfo != null )
 576         {
 577                 const _BufferInfoImpl* pBufferInfoImpl = null;
 578                 int displayHandle = _BufferInfoImpl::INVALID_BUFFER_HANDLE;
 579                 Rectangle rect;
 580                 camera_display_type_e displayType = CAMERA_DISPLAY_TYPE_NONE;
 581
 582                 pBufferInfoImpl = _BufferInfoImpl::GetInstance(*pBufferInfo);
 583                 SysTryCatch(NID_MEDIA, pBufferInfoImpl != null, r = E_SYSTEM, r, "[E_SYSTEM] A system error has been occurred.  BufferInfo is not found.");
 584                 if (pBufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION))
 585                 {
 586                         displayHandle = pBufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION);
 587                         displayType = ::CAMERA_DISPLAY_TYPE_X11;
 588                 }
 589                 else if (pBufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_CANVAS_TEXTURE))
 590                 {
 591                         displayHandle = pBufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_CANVAS_TEXTURE);
 592                         displayType = ::CAMERA_DISPLAY_TYPE_X11;
 593                 }
 594                 else if (pBufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_VE_SURFACE))
 595                 {
 596                         displayHandle = pBufferInfoImpl->GetHandle(_BufferInfoImpl::HANDLE_TYPE_VE_SURFACE);
 597                         displayType = ::CAMERA_DISPLAY_TYPE_EVAS;
 598                 }
 599                 SysLog(NID_MEDIA, "Display type %d", displayType);
 600                 SysTryCatch(NID_MEDIA, displayHandle != _BufferInfoImpl::INVALID_BUFFER_HANDLE, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  displayHandle:%d is wrong", displayHandle);
 601
 602                 if ((displayHandle != __previewRegionHandle) || (state != CAMERA_STATE_CAPTURED))
 603                 {
 604                         rect = pBufferInfoImpl->GetBounds();
 605
 606                         err = camera_set_display(__handle, displayType, (camera_display_h)displayHandle);
 607                         r = ConvertResult(err);
 608                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Camera set display failed. displayHandle:%d, previewedData:%d", GetErrorMessage(r), displayHandle, previewedData);
 609
 610                         if ( displayType == ::CAMERA_DISPLAY_TYPE_X11 )
 611                         {
 612                                 err = camera_set_x11_display_mode(__handle, ::CAMERA_DISPLAY_MODE_FULL);
 613                                 r = ConvertResult(err);
 614                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Camera set display mode failed. displayHandle:%d, previewedData:%d", GetErrorMessage(r), displayHandle, previewedData);
 615
 616                                 err = camera_set_x11_display_visible(__handle, true);
 617                                 r = ConvertResult(err);
 618                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Camera enabling display visible failed. displayHandle:%d, previewedData:%d", GetErrorMessage(r), displayHandle, previewedData);
 619
 620 #if defined (_CAMERA_EVAS_PIXMAP_)
 621                                 SysLog(NID_MEDIA, "Evas pixamp buffer is used. It doesn't rotate the display.");
 622
 623                                 err = camera_set_x11_display_rotation(__handle, ::CAMERA_ROTATION_NONE);                // No rotation.
 624                                 r = ConvertResult(err);
 625                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Camera rotate display 0 failed. displayHandle:%d, previewedData:%d", GetErrorMessage(r), displayHandle, previewedData);
 626                                 tempDisplayRotationType = CAMERA_ROTATION_NONE;
 627 #else
 628                                 //Only for h/w back buffer. Currently not used.
 629                                 CameraRotation displayRotation = CAMERA_ROTATION_NONE;
 630                                 _BufferInfoImpl::Rotation bufferInfoRotation = pBufferInfoImpl->GetRotation();
 631                                 SysLog(NID_MEDIA, "X11. BufferInfo's rotation is %d", bufferInfoRotation);
 632
 633                                 _BufferInfoImpl::Orientation orientation = pBufferInfoImpl->GetOrientation();
 634                                 SysLog(NID_MEDIA, "X11. Orientation is %d", orientation);
 635
 636                                 // Rotate the display corresponding the LCD orientationation.
 637                                 // This makes the unity of preview shape and the preview callback. This is osp camera concept.
 638                                 if ( bufferInfoRotation == _BufferInfoImpl::ROTATION_0 )                // If the OverlayRegion type is NORMAL
 639                                 {
 640                                         r = _CameraUtil::GetDisplayRotation(__physicalDirection, orientation, displayRotation);
 641                                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Camera display rotation failed in normal mode. physicalDirection:%d, orientationation:%d"
 642                                                 , GetErrorMessage(r), __physicalDirection, orientation);
 643                                 }
 644                                 else                                    // If the OverlayRegion type is AUTO
 645                                 {
 646                                         r = _CameraUtil::GetDisplayRotation(__physicalDirection, __physicalRotation, orientation, displayRotation);
 647                                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Camera display rotation failed in automatic mode. physicalDirection:%d, physicalRotation:%d, orientationation:%d"
 648                                                 , GetErrorMessage(r), __physicalDirection, __physicalRotation, orientation);
 649                                 }
 650
 651                                 camera_rotation_e mmRotation = ::CAMERA_ROTATION_NONE;
 652                                 r = _CameraUtil::GetMmRotation( displayRotation, mmRotation);
 653                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 654
 655                                 SysLog(NID_MEDIA, "X11. Try rotation Rotation MM value : %d", mmRotation);
 656                                 err = camera_set_x11_display_rotation(__handle, mmRotation);            // Auto adjust rotation - Primary Camera 270, Secondary Camera 90
 657                                 r = ConvertResult(err);
 658                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera rotate display failed. displayHandle:%d, previewedData:%d", GetErrorMessage(r), displayHandle, previewedData);
 659
 660                                 tempDisplayRotationType = displayRotation;
 661 #endif
 662                         }
 663                         tempDisplayRect = rect;
 664                         tempDisplayHandle = displayHandle;
 665                         tempDisplayType = displayType;
 666
 667                         __previewRegionRect = tempDisplayRect;  //currently not used.
 668                         __previewRegionHandle = tempDisplayHandle;
 669                         __previewDisplayType = tempDisplayType;
 670                         __displayRotationType = tempDisplayRotationType;
 671                 }
 672         }
 673         else
 674         {
 675                 err = camera_set_display(__handle, ::CAMERA_DISPLAY_TYPE_NONE, null);
 676                 r = ConvertResult(err);
 677                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera set display(null) failed. previewedData:%d", GetErrorMessage(r), previewedData);
 678                 __previewRegionHandle = _BufferInfoImpl::INVALID_BUFFER_HANDLE;
 679         }
 680
 681         switch (mmState)
 682         {
 683         case ::CAMERA_STATE_CREATED:
 684         case ::CAMERA_STATE_CAPTURED:
 685                 r = __pCoordinator->StartMmPreview();
 686                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera start.", GetErrorMessage(r));
 687                 break;
 688
 689         default:
 690                 SysTryCatch(NID_MEDIA, false, r = E_INVALID_STATE , E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. The mmState is %d:", mmState);
 691                 break;
 692         }
 693
 694         if (previewedData)
 695         {
 696                 __previewProcessing = __previewProcessing | _PREVIEW_POST_PROCESSING;
 697         }
 698         else
 699         {
 700                 __previewProcessing = __previewProcessing & (~_PREVIEW_POST_PROCESSING);
 701         }
 702
 703
 704         SetState(CAMERA_STATE_PREVIEW);
 705         return r;
 706
 707 CATCH:
 708         err = camera_unset_preview_cb(__handle);
 709         __previewRegionHandle = _BufferInfoImpl::INVALID_BUFFER_HANDLE;
 710         __previewDisplayType = ::CAMERA_DISPLAY_TYPE_NONE;
 711         __displayRotationType = CAMERA_ROTATION_NONE;
 712         return r;
 713 }
 714
 715 result
 716 _CameraImpl::StopPreview(void)
 717 {
 718         result r = E_SUCCESS;
 719         CameraState state = CAMERA_STATE_ERROR;
 720         SysLog(NID_MEDIA, "Camera stop preview");
 721         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
 722
 723         state = GetState();
 724         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_PREVIEW, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state(%d). Camera is not in preview state.", state);
 725
 726         r = __pCoordinator->StopMmPreview();
 727         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] camera stop  preview.");
 728
 729         if(__previewDisplayType == CAMERA_DISPLAY_TYPE_EVAS)
 730         {
 731                 if(__previewRegionHandle != _BufferInfoImpl::INVALID_BUFFER_HANDLE)
 732                 {
 733                         evas_object_image_data_set((Evas_Object*)__previewRegionHandle, null);
 734                 }
 735         }
 736
 737         SetState(CAMERA_STATE_INITIALIZED);
 738         return r;
 739 }
 740
 741 result
 742 _CameraImpl::Capture(void)
 743 {
 744         result r = E_SUCCESS;
 745         CameraState state = CAMERA_STATE_ERROR;
 746         camera_pixel_format_e previewFormat = ::CAMERA_PIXEL_FORMAT_INVALID;
 747         SysLog(NID_MEDIA, "Camera Capture");
 748         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
 749
 750         state = GetState();
 751         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_PREVIEW, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state(%d). Camera is not in preview state.", state);
 752
 753         if ( __pCoordinator->GetMode() != _CAMERA_MODE_IMAGE )
 754         {
 755                 r = _CameraUtil::GetMmPixelFormat(__previewFormat, previewFormat);
 756                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. __previewFormat:%d", GetErrorMessage(r), __previewFormat);
 757                 if (previewFormat != __pCoordinator->GetCameraSourceFormat())
 758                 {
 759                         r = __pCoordinator->ChangeFormat(_CAMERA_MODE_IMAGE, true, previewFormat);
 760                         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 761                 }
 762         }
 763
 764         r = __pCoordinator->StartCapture(CaptureCb, CaptureCompletedCb, this);
 765         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Start capture failed.", GetErrorMessage(r));
 766
 767         SetState(CAMERA_STATE_CAPTURING);
 768         return r;
 769 }
 770
 771 CameraState
 772 _CameraImpl::GetState(void) const
 773 {
 774         if (__state == CAMERA_STATE_PREVIEW || __state == CAMERA_STATE_AUTO_FOCUSING ||  __state == CAMERA_STATE_CAPTURING)
 775         {
 776                 camera_state_e mmState = GetMmState();
 777                 if (mmState == ::CAMERA_STATE_CREATED) // If the preview is stopped by some internal policy.
 778                 {
 779                         return CAMERA_STATE_INITIALIZED;
 780                 }
 781         }
 782         return __state;
 783 }
 784
 785 result
 786 _CameraImpl::SetBrightness(int brightness)
 787 {
 788         result r = E_SUCCESS;
 789         _CameraOperationType operation = _COP_NONE;
 790         CameraState state = CAMERA_STATE_ERROR;
 791         SysLog(NID_MEDIA, "Enter. brightness:%d", brightness);
 792
 793         state = GetState();
 794         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
 795                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
 796
 797         SysTryReturn(NID_MEDIA, (brightness >= MIN_CAMERA_BRIGHTNESS &&  brightness <= MAX_CAMERA_BRIGHTNESS), E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 798                                 "[E_OUT_OF_RANGE] The brightness(%d) is out of range. The brightness must be in the range between 0 ~ 9.", brightness);
 799
 800         if (__isPoweredOn)
 801         {
 802                 if(__sceneMode != CAMERA_SCENE_OFF)
 803                 {//because this attribute is related to scene mode.
 804                         r = SetSceneModeAttr(CAMERA_SCENE_OFF);
 805                         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. ResetSceneMode", GetErrorMessage(r));
 806                 }
 807                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_BRIGHTNESS : _COP_SECONDARY_BRIGHTNESS);
 808                 r = SetProperty(operation, _MIN_PROPERTY, _MAX_PROPERTY, brightness);
 809                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. brightness:%d", GetErrorMessage(r), brightness);
 810         }
 811
 812         __brightness = brightness;
 813         return r;
 814 }
 815
 816 int
 817 _CameraImpl::GetBrightness(void) const
 818 {
 819         return __brightness;
 820 }
 821
 822 result
 823 _CameraImpl::SetContrast(int contrast)
 824 {
 825         result r = E_SUCCESS;
 826         _CameraOperationType operation = _COP_NONE;
 827         CameraState state = CAMERA_STATE_ERROR;
 828         SysLog(NID_MEDIA, "Enter. contrast:%d", contrast);
 829
 830         state = GetState();
 831         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
 832                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
 833
 834         SysTryReturn(NID_MEDIA, contrast >= MIN_CAMERA_CONTRAST && contrast <= MAX_CAMERA_CONTRAST, E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 835                                 "[E_OUT_OF_RANGE] The contrast(%d) is out of range. The contrast must be in the range between 0 ~ 9.", contrast);
 836
 837         if (__isPoweredOn)
 838         {
 839                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_CONTRAST : _COP_SECONDARY_CONTRAST);
 840                 r = SetProperty(operation, _MIN_PROPERTY, _MAX_PROPERTY, contrast);
 841                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. contrast:%d", GetErrorMessage(r), contrast);
 842         }
 843
 844         __contrast = contrast;
 845         return r;
 846 }
 847
 848 int
 849 _CameraImpl::GetContrast(void) const
 850 {
 851         return __contrast;
 852 }
 853
 854 result
 855 _CameraImpl::ZoomIn(void)
 856 {
 857         result r = E_SUCCESS;
 858         int zoomLevel = 0;
 859         CameraState state = CAMERA_STATE_ERROR;
 860         _CameraOperationType operation = _COP_NONE;
 861         SysLog(NID_MEDIA, "Camera zoomIn");
 862         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
 863
 864         state = GetState();
 865         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_PREVIEW
 866                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
 867
 868         bool supported = false;
 869         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_ZOOM_LEVEL : _COP_SECONDARY_ZOOM_LEVEL);
 870         supported = _CameraCapability::IsSupported(operation);
 871         SysTryReturn(NID_MEDIA, supported == true, E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The operation:%d is not supported.", operation);
 872
 873         zoomLevel = __zoomLevel + 1;
 874         SysTryReturn(NID_MEDIA, zoomLevel <= __maxZoomLevel && zoomLevel >= __minZoomLevel ,
 875                 E_DEVICE_FAILED, E_DEVICE_FAILED, "[E_DEVICE_FAILED] No more ZoomIn. zoomLevel:%d", zoomLevel);
 876
 877         r = SetProperty(operation, __minZoomLevel, __maxZoomLevel, zoomLevel);
 878
 879         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 880
 881         __zoomLevel = zoomLevel;
 882         return r;
 883 }
 884
 885 result
 886 _CameraImpl::ZoomOut(void)
 887 {
 888         result r = E_SUCCESS;
 889         int zoomLevel = 0;
 890         CameraState state = CAMERA_STATE_ERROR;
 891         _CameraOperationType operation = _COP_NONE;
 892         SysLog(NID_MEDIA, "Camera zoomOut");
 893         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
 894
 895         state = GetState();
 896         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_PREVIEW
 897                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
 898
 899         bool supported = false;
 900         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_ZOOM_LEVEL : _COP_SECONDARY_ZOOM_LEVEL);
 901         supported = _CameraCapability::IsSupported(operation);
 902         SysTryReturn(NID_MEDIA, supported == true, E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The operation:%d is not supported.", operation);
 903
 904         zoomLevel = __zoomLevel - 1;
 905         SysTryReturn(NID_MEDIA, zoomLevel <= __maxZoomLevel, E_DEVICE_FAILED, E_DEVICE_FAILED, "[E_DEVICE_FAILED] No more ZoomOut. zoomLevel:%d", zoomLevel);
 906         SysTryReturn(NID_MEDIA, zoomLevel >= __minZoomLevel, E_DEVICE_FAILED, E_DEVICE_FAILED, "[E_DEVICE_FAILED] No more ZoomIn. ZoomOut:%d", zoomLevel);
 907
 908         r = SetProperty(operation, __minZoomLevel, __maxZoomLevel, zoomLevel);
 909
 910         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 911
 912         __zoomLevel = zoomLevel;
 913         return r;
 914 }
 915
 916 int
 917 _CameraImpl::GetMaxZoomLevel(void) const
 918 {
 919         result r = E_SUCCESS;
 920         int returnMaxZoomLevel = 0;
 921         int minZoom = 0;
 922         int maxZoom = 0;
 923         _CameraOperationType operation = _COP_NONE;
 924         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_ZOOM_LEVEL : _COP_SECONDARY_ZOOM_LEVEL);
 925         r = GetProperty(operation, minZoom, maxZoom);
 926         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. minZoom:%d, maxZoom:%d", GetErrorMessage(r), minZoom, maxZoom);
 927
 928         returnMaxZoomLevel = maxZoom - minZoom;
 929         SysTryCatch(NID_MEDIA, returnMaxZoomLevel > 0, , E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Retrived zoom values are wrong. minZoom:%d, maxZoom:%d", GetErrorMessage(r), minZoom, maxZoom);
 930
 931         SysLog(NID_MEDIA, "Max zoom level is %d", returnMaxZoomLevel);
 932         return returnMaxZoomLevel;
 933
 934 CATCH:
 935         return MEDIA_INVALID_VALUE;
 936 }
 937
 938 int
 939 _CameraImpl::GetZoomLevel(void) const
 940 {
 941         return __zoomLevel;
 942 }
 943
 944 result
 945 _CameraImpl::SetPreviewResolution(const Tizen::Graphics::Dimension& resolution)
 946 {
 947         result r = E_SUCCESS;
 948         CameraState state = CAMERA_STATE_ERROR;
 949         int err = MM_SUCCESS;
 950         SysLog(NID_MEDIA, "Enter. resolution(%d,%d)", resolution.width, resolution.height);
 951
 952         state = GetState();
 953         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED, E_INVALID_STATE, E_INVALID_STATE,
 954                                 "[E_INVALID_STATE] Camera is in an invalid state. This method is working in CAMERA_STATE_INITIALIZED state. Current state is :%d", state);
 955
 956         std::unique_ptr <IList, _ListPtrUtil::Remover> pList (GetSupportedPreviewResolutionListN(), _ListPtrUtil::remover);
 957         SysTryCatch(NID_MEDIA, pList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
 958         SysTryCatch(NID_MEDIA, pList->Contains(resolution), r = E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 959                 "[E_OUT_OF_RANGE]The resolution(%d,%d) is out of range. This resolution is not supported in the device.\n", resolution.width, resolution.height);
 960
 961         err = camera_set_preview_resolution(__handle, resolution.width, resolution.height);
 962         r = ConvertResult(err);
 963         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 964
 965         __previewResolution.width = resolution.width;
 966         __previewResolution.height = resolution.height;
 967
 968 CATCH:
 969         return r;
 970 }
 971
 972 Tizen::Graphics::Dimension
 973 _CameraImpl::GetPreviewResolution(void) const
 974 {
 975         return __previewResolution;
 976 }
 977
 978 Tizen::Base::Collection::IList*
 979 _CameraImpl::GetSupportedPreviewResolutionListN(void) const
 980 {
 981         result r = E_SUCCESS;
 982         _CameraOperationType operation = _COP_NONE;
 983
 984         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_PREVIEW_RESOLUTION : _COP_SECONDARY_PREVIEW_RESOLUTION);
 985         std::unique_ptr <IList, _ListPtrUtil::Remover> pResolutionList (GetPropertyListN(operation, _RESULT_DIMENSION_LIST), _ListPtrUtil::remover);
 986         SysTryCatch(NID_MEDIA, pResolutionList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
 987         SysTryCatch(NID_MEDIA, pResolutionList->GetCount() > 0, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
 988
 989         return pResolutionList.release();
 990
 991 CATCH:
 992         return null;
 993 }
 994
 995 result
 996 _CameraImpl::SetCaptureResolution(const Tizen::Graphics::Dimension& resolution)
 997 {
 998         result r = E_SUCCESS;
 999         CameraState state = CAMERA_STATE_ERROR;
1000         int err = MM_SUCCESS;
1001         SysLog(NID_MEDIA, "Enter. resolution(%d,%d)", resolution.width, resolution.height);
1002
1003         state = GetState();
1004         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1005                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1006
1007         std::unique_ptr <IList, _ListPtrUtil::Remover> pList (GetSupportedCaptureResolutionListN(), _ListPtrUtil::remover);
1008         SysTryCatch(NID_MEDIA, pList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
1009         SysTryCatch(NID_MEDIA, pList->Contains(resolution), r = E_OUT_OF_RANGE, E_OUT_OF_RANGE,
1010                 "[E_OUT_OF_RANGE]. This resolution(%d,%d)is out of range. This resolution is not supported in the device.\n", resolution.width, resolution.height);
1011
1012         err = camera_set_capture_resolution(__handle, resolution.width, resolution.height);
1013         r = ConvertResult(err);
1014         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1015
1016         __captureResolution.width = resolution.width;
1017         __captureResolution.height = resolution.height;
1018
1019 CATCH:
1020         return r;
1021 }
1022
1023
1024 Tizen::Graphics::Dimension
1025 _CameraImpl::GetCaptureResolution(void) const
1026 {
1027         return __captureResolution;
1028 }
1029
1030
1031 Tizen::Base::Collection::IList*
1032 _CameraImpl::GetSupportedCaptureResolutionListN(void) const
1033 {
1034         result r = E_SUCCESS;
1035         _CameraOperationType operation = _COP_NONE;
1036
1037         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_CAPTURE_RESOLUTION : _COP_SECONDARY_CAPTURE_RESOLUTION);
1038         std::unique_ptr <IList, _ListPtrUtil::Remover> pResolutionList (GetPropertyListN(operation, _RESULT_DIMENSION_LIST), _ListPtrUtil::remover);
1039         SysTryCatch(NID_MEDIA, pResolutionList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
1040         SysTryCatch(NID_MEDIA, pResolutionList->GetCount() > 0, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
1041
1042         return pResolutionList.release();
1043
1044 CATCH:
1045         return null;
1046 }
1047
1048 result
1049 _CameraImpl::SetEffect(CameraEffect effect)
1050 {
1051         result r = E_SUCCESS;
1052         CameraState state = CAMERA_STATE_ERROR;
1053         int err = MM_SUCCESS;
1054         _ResultType itemType = _RESULT_INTEGER_LIST;
1055
1056         SysLog(NID_MEDIA, "Enter. effect:%d", effect);
1057
1058         state = GetState();
1059         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1060                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1061
1062         SysTryReturn(NID_MEDIA, effect >= CAMERA_EFFECT_NONE && effect <= CAMERA_EFFECT_NIGHT, E_INVALID_ARG, E_INVALID_ARG
1063                            , "[E_INVALID_ARG] Invalid argument(effect) is used. effect=%d.", effect);
1064
1065         if (__isPoweredOn)
1066         {
1067                 _CameraOperationType operation = _COP_NONE;
1068
1069                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_EFFECT : _COP_SECONDARY_EFFECT);
1070
1071                 std::unique_ptr <IList, _ListPtrUtil::Remover> pEffectList (GetPropertyListN(operation, itemType), _ListPtrUtil::remover);
1072                 SysTryCatch(NID_MEDIA, pEffectList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The operation:%d is not supported.", operation);
1073                 SysTryCatch(NID_MEDIA, pEffectList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1074                 SysTryCatch(NID_MEDIA, pEffectList->Contains(Integer(effect)), r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This effect(%d) is not supported in the device.\n",  effect);
1075
1076                 camera_attr_effect_mode_e attr = ::CAMERA_ATTR_EFFECT_NONE;
1077                 r = _CameraUtil::GetMmEffect(effect, attr);
1078                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. effect:%d", GetErrorMessage(r), effect);
1079
1080                 err = camera_attr_set_effect(__handle, attr);
1081                 r = ConvertResult(err);
1082                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. effect:%d", GetErrorMessage(r), effect);
1083
1084         }
1085         __effect = effect;
1086
1087 CATCH:
1088         return r;
1089 }
1090
1091 CameraEffect
1092 _CameraImpl::GetEffect(void) const
1093 {
1094         return __effect;
1095 }
1096
1097 result
1098 _CameraImpl::SetFlashMode(CameraFlashMode flashMode)
1099 {
1100         result r = E_SUCCESS;
1101         CameraState state = CAMERA_STATE_ERROR;
1102         int err = MM_SUCCESS;
1103         _ResultType itemType = _RESULT_INTEGER_LIST;
1104         SysLog(NID_MEDIA, "Enter. flashMode:%d", flashMode);
1105
1106         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
1107
1108         state = GetState();
1109         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1110                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1111         SysTryReturn(NID_MEDIA, flashMode >= CAMERA_FLASH_MODE_OFF, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(flashMode) is used. flashMode=%d", flashMode);
1112
1113         _CameraOperationType operation = _COP_NONE;
1114         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_FLASH_MODE : _COP_SECONDARY_FLASH_MODE);
1115         camera_attr_flash_mode_e attr = ::CAMERA_ATTR_FLASH_MODE_OFF;
1116
1117         std::unique_ptr <IList, _ListPtrUtil::Remover> pFlashModeList (GetPropertyListN(operation, itemType), _ListPtrUtil::remover);
1118         SysTryCatch(NID_MEDIA, pFlashModeList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The operation:%d is not supported.", operation);
1119         SysTryCatch(NID_MEDIA, pFlashModeList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1120         SysTryCatch(NID_MEDIA, pFlashModeList->Contains(Integer(flashMode)) || flashMode == CAMERA_FLASH_MODE_OFF,
1121                 r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This flashMode(%d) is not supported in the device.\n",  flashMode);
1122
1123         if(__sceneMode != CAMERA_SCENE_OFF)
1124         {//because this attribute is related to scene mode.
1125                 r = SetSceneModeAttr(CAMERA_SCENE_OFF);
1126                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. ResetSceneMode", GetErrorMessage(r));
1127         }
1128         r = _CameraUtil::GetMmFlashMode(flashMode, attr);
1129         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. flashMode:%d", GetErrorMessage(r), flashMode);
1130
1131         err = camera_attr_set_flash_mode(__handle, attr);
1132         r = ConvertResult(err);
1133         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. flashMode:%d", GetErrorMessage(r), flashMode);
1134
1135         __flashMode = flashMode;
1136
1137 CATCH:
1138         return r;
1139 }
1140
1141
1142 CameraFlashMode
1143 _CameraImpl::GetFlashMode(void) const
1144 {
1145         return __flashMode;
1146 }
1147
1148 result
1149 _CameraImpl::SetExposure(int exposure)
1150 {
1151         result r = E_SUCCESS;
1152         CameraState state = CAMERA_STATE_ERROR;
1153         _CameraOperationType operation = _COP_NONE;
1154         SysLog(NID_MEDIA, "Enter. exposure:%d", exposure);
1155
1156         state = GetState();
1157         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1158                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1159
1160         SysTryReturn(NID_MEDIA, exposure >= MIN_CAMERA_EXPOSURE && exposure <= MAX_CAMERA_EXPOSURE, E_OUT_OF_RANGE, E_OUT_OF_RANGE
1161                            , "[E_OUT_OF_RANGE] This exposure(%d)is out of range. The exposure MUST be in the range between 0 ~ 9.", exposure);
1162
1163         if (__isPoweredOn)
1164         {
1165                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_EXPOSURE : _COP_SECONDARY_EXPOSURE);
1166                 r = SetProperty(operation, _MIN_PROPERTY, _MAX_PROPERTY, exposure);
1167                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. exposure:%d", GetErrorMessage(r), exposure);
1168         }
1169
1170         __exposure = exposure;
1171         return r;
1172 }
1173
1174 int
1175 _CameraImpl::GetExposure(void) const
1176 {
1177         return __exposure;
1178 }
1179
1180 result
1181 _CameraImpl::SetWhiteBalance(CameraWhiteBalance whiteBalance)
1182 {
1183         result r = E_SUCCESS;
1184         CameraState state = CAMERA_STATE_ERROR;
1185         int err = MM_SUCCESS;
1186         _ResultType itemType = _RESULT_INTEGER_LIST;
1187         SysLog(NID_MEDIA, "Enter. whiteBalance:%d", whiteBalance);
1188
1189         state = GetState();
1190         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1191                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1192
1193         SysTryReturn(NID_MEDIA, whiteBalance >= CAMERA_WHITE_BALANCE_AUTO && whiteBalance <= CAMERA_WHITE_BALANCE_TUNGSTEN,
1194                                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(whiteBalance) is used. whiteBalance:%d", whiteBalance);
1195
1196         if (__isPoweredOn)
1197         {
1198                 _CameraOperationType operation = _COP_NONE;
1199                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_WHITE_BALANCE : _COP_SECONDARY_WHITE_BALANCE);
1200
1201                 std::unique_ptr <IList, _ListPtrUtil::Remover> pWbList (GetPropertyListN(operation, itemType), _ListPtrUtil::remover);
1202                 SysTryCatch(NID_MEDIA, pWbList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The operation:%d is not supported.", operation);
1203                 SysTryCatch(NID_MEDIA, pWbList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1204                 SysTryCatch(NID_MEDIA, pWbList->Contains(Integer(whiteBalance)), r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This whiteBalance(%d) is not supported in the device.\n",  whiteBalance);
1205
1206                 if(__sceneMode != CAMERA_SCENE_OFF)
1207                 {//because this attribute is related to scene mode.
1208                         r = SetSceneModeAttr(CAMERA_SCENE_OFF);
1209                         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. ResetSceneMode", GetErrorMessage(r));
1210                 }
1211                 camera_attr_whitebalance_e attr = ::CAMERA_ATTR_WHITE_BALANCE_NONE;
1212                 r = _CameraUtil::GetMmWhiteBalance(whiteBalance, attr);
1213                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. whiteBalance:%d", GetErrorMessage(r), whiteBalance);
1214
1215                 err = camera_attr_set_whitebalance(__handle, attr);
1216                 r = ConvertResult(err);
1217                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. whiteBalance:%d", GetErrorMessage(r), whiteBalance);
1218         }
1219         __wb = whiteBalance;
1220
1221 CATCH:
1222         return r;
1223 }
1224
1225 CameraWhiteBalance
1226 _CameraImpl::GetWhiteBalance(void) const
1227 {
1228         return __wb;
1229 }
1230
1231 result
1232 _CameraImpl::SetQuality(CameraQuality quality)
1233 {
1234         result r = E_SUCCESS;
1235         CameraState state = CAMERA_STATE_ERROR;
1236         int err = MM_SUCCESS;
1237         SysLog(NID_MEDIA, "Enter. quality:%d", quality);
1238
1239         state = GetState();
1240         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1241                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state.This method is not working in this state. Current state is :%d", state);
1242
1243         SysTryReturn(NID_MEDIA, quality >= CAMERA_QUALITY_NORMAL && quality <= CAMERA_QUALITY_MAX, E_OUT_OF_RANGE, E_OUT_OF_RANGE
1244                 , "[E_OUT_OF_RANGE]  This quality(%d)is out of range.", quality);
1245
1246         if (__isPoweredOn)
1247         {
1248                 int attr = 0;
1249                 r = _CameraUtil::GetMmQuality(quality, attr);
1250                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. quality:%d", GetErrorMessage(r), quality);
1251
1252                 err = camera_attr_set_image_quality(__handle, attr);
1253                 r = ConvertResult(err);
1254                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. quality:%d", GetErrorMessage(r), quality);
1255         }
1256         __quality = quality;
1257
1258         return r;
1259
1260 CATCH:
1261         return r;
1262 }
1263
1264 CameraQuality
1265 _CameraImpl::GetQuality(void) const
1266 {
1267         return __quality;
1268 }
1269
1270 result
1271 _CameraImpl::SetFocusMode(CameraFocusMode focusMode)
1272 {
1273         result r = E_SUCCESS;
1274         CameraState state = CAMERA_STATE_ERROR;
1275         String key = (__selection == CAMERA_PRIMARY ? CAMERA_PRIMARY_FOCUS_MODE : CAMERA_SECONDARY_FOCUS_MODE);
1276         SysLog(NID_MEDIA, "Enter. focusMode:%d", focusMode);
1277
1278         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
1279
1280         state = GetState();
1281         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1282                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1283         SysTryReturn(NID_MEDIA, focusMode > CAMERA_FOCUS_MODE_NONE, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(focusMode) is used. focusMode=%d", focusMode);
1284
1285         std::unique_ptr <IList, _ListPtrUtil::Remover> pSupportedList (GetPropertyListN(key), _ListPtrUtil::remover);
1286         SysTryCatch(NID_MEDIA, pSupportedList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1287         SysTryCatch(NID_MEDIA, pSupportedList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1288         SysTryCatch(NID_MEDIA, pSupportedList->Contains(Integer(focusMode))
1289                 , r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This mode(%d) is not supported in the device.\n",  focusMode);
1290
1291         if(__sceneMode != CAMERA_SCENE_OFF)
1292         {//because this attribute is related to scene mode.
1293                 r = SetSceneModeAttr(CAMERA_SCENE_OFF);
1294                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. ResetSceneMode", GetErrorMessage(r));
1295         }
1296         // Set the __focusCallback to false not to call the focus callback in case of CAF.
1297         r = ChangeFocusModeTo(__focusMode, focusMode);
1298         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. current focus mode is %d, new focus mode is %d", GetErrorMessage(r), __focusMode, focusMode);
1299
1300         __focusCallback = false;
1301         __focusMode = focusMode;
1302
1303 CATCH:
1304         return r;
1305 }
1306
1307 CameraFocusMode
1308 _CameraImpl::GetFocusMode(void) const
1309 {
1310         return __focusMode;
1311 }
1312
1313 result
1314 _CameraImpl::SetAutoFocus(bool callback)
1315 {
1316         result r = E_SUCCESS;
1317         CameraState state = CAMERA_STATE_ERROR;
1318         SysLog(NID_MEDIA, "Enter. callback:%d, focus mode:%d", callback, __focusMode);
1319
1320         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
1321         SysTryReturn(NID_MEDIA, __focusMode >= CAMERA_FOCUS_MODE_NORMAL && __focusMode <= CAMERA_FOCUS_MODE_CONTINUOUS_AUTO
1322                 , E_DEVICE_FAILED, E_DEVICE_FAILED, "[E_DEVICE_FAILED] In the focus mode:%d, this method is not working.", __focusMode);
1323
1324         state = GetState();
1325         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_PREVIEW, E_INVALID_STATE, E_INVALID_STATE,
1326                 "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1327
1328         r = HandleAutoFocus(__focusMode);
1329         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. focus mode is %d, callback:%s", GetErrorMessage(r), __focusMode, callback);
1330
1331         __focusCallback = callback;
1332         return r;
1333
1334 CATCH:
1335         return r;
1336 }
1337
1338 bool
1339 _CameraImpl::ReadyToAutoFocusCallback(void) const
1340 {
1341         return __focusCallback;
1342 }
1343
1344 result
1345 _CameraImpl::SetAutoFocusPoint(const Tizen::Base::Collection::IList& pointList)
1346 {
1347         result r = E_SUCCESS;
1348         int err = MM_SUCCESS;
1349         CameraState state = CAMERA_STATE_ERROR;
1350         int pointCount = 0;
1351         int i = 0;
1352         pointCount = pointList.GetCount();
1353         SysLog(NID_MEDIA, "Enter. pointList count :%d", pointCount);
1354
1355         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camera was not powered on.");
1356
1357         state = GetState();
1358         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_PREVIEW
1359                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1360
1361         SysTryReturn(NID_MEDIA, __focusMode == CAMERA_FOCUS_MODE_NORMAL || __focusMode == CAMERA_FOCUS_MODE_MACRO
1362                 , E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE , "[E_UNSUPPORTED_TYPE ] The method is not supported in the current focus mode(%d).", __focusMode);
1363
1364         SysTryCatch(NID_MEDIA, pointCount >= 0 && pointCount <= __supportedFocusPointCount
1365                 , r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(pointCount) is used. pointCount=%d");
1366
1367         if (pointCount > 0)
1368         {
1369                 // Total input points
1370                 while (i < pointCount && i < MAX_FOCUS_POINT)
1371                 {
1372                         Object* pObj = null;
1373                         Point* pPoint = null;
1374
1375                         pObj = const_cast<Object*>(pointList.GetAt(i));
1376                         SysTryCatch(NID_MEDIA, pObj != null, r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(item) is used. %d item is not found.", i);
1377
1378                         pPoint = dynamic_cast<Point*>(pObj);
1379                         SysTryCatch(NID_MEDIA, pPoint != null, r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(item's format) is used. %d item's format is invalid.", i);
1380
1381                         err = camera_attr_set_af_area(__handle, pPoint->x, pPoint->y);
1382                         r = ConvertResult(err);
1383                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1384                         SysLog(NID_MEDIA, "%dst af area(%d, %d) was set successfully", i, pPoint->x, pPoint->y);
1385
1386                         // Preserve the points
1387                         __focusPoints[0][i] = pPoint->x;
1388                         __focusPoints[1][i] = pPoint->y;
1389
1390                         i++;
1391                 }
1392
1393                 if ( i < MAX_FOCUS_POINT )
1394                 {
1395                         __focusPoints[0][i] = _INVALID_FOCUS_COORDINATE;
1396                         __focusPoints[1][i] = _INVALID_FOCUS_COORDINATE;
1397                 }
1398
1399                 __isFocusAreaSet = true;
1400         }
1401         else            //If pointCount is zero, Set focus point to defualt area.
1402         {
1403                 if (__isFocusAreaSet)
1404                 {
1405                         err = camera_attr_clear_af_area(__handle);
1406                         r = ConvertResult(err);
1407                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1408                         SysLog(NID_MEDIA, "the focus area is changed to the center.");
1409                 }
1410                 for(int j = 0; j < MAX_FOCUS_POINT; j++)
1411                 {
1412                         __focusPoints[0][j] = _INVALID_FOCUS_COORDINATE;
1413                         __focusPoints[1][j] = _INVALID_FOCUS_COORDINATE;
1414                 }
1415                 __isFocusAreaSet = false;
1416         }
1417
1418         return r;
1419
1420 CATCH:
1421         return r;
1422 }
1423
1424 Tizen::Base::Collection::IList*
1425 _CameraImpl::GetAutoFocusPointN(void) const
1426 {
1427         result r = E_SUCCESS;
1428         int i = 0;
1429
1430         //Create new list
1431         std::unique_ptr <_MediaSafeArrayList, _ListPtrUtil::Remover> pFocusPointList (new (std::nothrow) _MediaSafeArrayList(), _ListPtrUtil::remover);
1432         SysTryCatch(NID_MEDIA, pFocusPointList.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
1433
1434         r = pFocusPointList->Construct();
1435         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1436
1437         while (__focusPoints[0][i] != _INVALID_FOCUS_COORDINATE && __focusPoints[1][i] != _INVALID_FOCUS_COORDINATE)
1438         {
1439                 std::unique_ptr <Object> pPoint (new (std::nothrow) Point(__focusPoints[0][i], __focusPoints[1][i]));
1440                 SysTryCatch(NID_MEDIA, pPoint.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
1441
1442                 r = pFocusPointList->AddPtr(std::move(pPoint));
1443                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1444                 i++;
1445         }
1446         return pFocusPointList.release();
1447
1448 CATCH:
1449         return null;
1450 }
1451
1452 result
1453 _CameraImpl::SetCaptureFormat(const Tizen::Graphics::PixelFormat format)
1454 {
1455         result r = E_SUCCESS;
1456         int err = MM_SUCCESS;
1457         CameraState state = CAMERA_STATE_ERROR;
1458         camera_pixel_format_e attr = ::CAMERA_PIXEL_FORMAT_INVALID;
1459         SysLog(NID_MEDIA, "Enter. format:%d", format);
1460
1461         state = GetState();
1462         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1463                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1464
1465         std::unique_ptr <IListT<Tizen::Graphics::PixelFormat>, _ListPtrUtil::Remover> pList (GetSupportedCaptureFormatListN(), _ListPtrUtil::remover);
1466         SysTryCatch(NID_MEDIA, pList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
1467         SysTryCatch(NID_MEDIA, pList->Contains(format), r = E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT]. This format(%d) is not supported in the device.\n", format);
1468
1469         r = _CameraUtil::GetMmPixelFormat(format, attr);
1470         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. pixel format:%d", GetErrorMessage(r), format);
1471
1472         err = camera_set_capture_format(__handle, attr);
1473         r = ConvertResult(err);
1474         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1475
1476         __captureFormat = format;
1477
1478 CATCH:
1479         return r;
1480 }
1481
1482 Tizen::Graphics::PixelFormat
1483 _CameraImpl::GetCaptureFormat(void) const
1484 {
1485         return __captureFormat;
1486 }
1487
1488
1489 Tizen::Base::Collection::IListT<Tizen::Graphics::PixelFormat>*
1490 _CameraImpl::GetSupportedCaptureFormatListN(void) const
1491 {
1492         result r = E_SUCCESS;
1493         _CameraOperationType operation = _COP_NONE;
1494
1495         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_CAPTURE_FORMAT : _COP_SECONDARY_CAPTURE_FORMAT);
1496         std::unique_ptr <IList, _ListPtrUtil::Remover> pIntegerList (GetPropertyListN(operation, _RESULT_INTEGER_LIST), _ListPtrUtil::remover);
1497         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
1498         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
1499
1500         std::unique_ptr <Tizen::Base::Collection::ArrayListT<Tizen::Graphics::PixelFormat>, _ListPtrUtil::Remover> pFormatList (new (std::nothrow) ArrayListT<Tizen::Graphics::PixelFormat>(), _ListPtrUtil::remover);
1501         SysTryReturn(NID_MEDIA, pFormatList.get() != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
1502
1503         r = pFormatList->Construct();
1504         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1505
1506         for (int i = 0; i < pIntegerList->GetCount(); i++)
1507         {
1508                 Object* pObj = null;
1509                 Integer* pInteger = null;
1510                 pObj = pIntegerList->GetAt(i);
1511                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object instance is not available. %d item is not found.", i);
1512
1513                 pInteger = dynamic_cast<Integer*>(pObj);
1514                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's format is invalid.", i);
1515
1516                 r = pFormatList->Add((Tizen::Graphics::PixelFormat)pInteger->ToInt());
1517                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1518                 SysLog(NID_MEDIA, "Pixel format : %d was added.", pInteger->ToInt());
1519         }
1520
1521         return pFormatList.release();
1522
1523 CATCH:
1524         return null;
1525 }
1526
1527 result
1528 _CameraImpl::SetPreviewFormat(const Tizen::Graphics::PixelFormat format)
1529 {
1530         result r = E_SUCCESS;
1531         CameraState state = CAMERA_STATE_ERROR;
1532         camera_pixel_format_e attr = ::CAMERA_PIXEL_FORMAT_INVALID;
1533         SysLog(NID_MEDIA, "Enter. format:%d", format);
1534
1535         state = GetState();
1536         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_CAPTURED , E_INVALID_STATE, E_INVALID_STATE,
1537                                 "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1538
1539         std::unique_ptr <IListT<Tizen::Graphics::PixelFormat>, _ListPtrUtil::Remover> pList (GetSupportedPreviewFormatListN(), _ListPtrUtil::remover);
1540         SysTryCatch(NID_MEDIA, pList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
1541         SysTryCatch(NID_MEDIA, pList->Contains(format), r = E_UNSUPPORTED_FORMAT, E_UNSUPPORTED_FORMAT,
1542                 "[E_UNSUPPORTED_FORMAT]. This format(%d) is not supported in the device.\n", format);
1543
1544         r = _CameraUtil::GetMmPixelFormat(format, attr);
1545         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. pixel format:%d", GetErrorMessage(r), format);
1546
1547         r = __pCoordinator->SetCameraSourceFormat(attr);
1548         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1549
1550         __previewFormat = format;
1551
1552 CATCH:
1553         return r;
1554 }
1555
1556 Tizen::Graphics::PixelFormat
1557 _CameraImpl::GetPreviewFormat(void) const
1558 {
1559         return __previewFormat;
1560 }
1561
1562
1563 Tizen::Base::Collection::IListT<Tizen::Graphics::PixelFormat>*
1564 _CameraImpl::GetSupportedPreviewFormatListN(void) const
1565 {
1566         result r = E_SUCCESS;
1567         _CameraOperationType operation = _COP_NONE;
1568
1569         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_PREVIEW_FORMAT : _COP_SECONDARY_PREVIEW_FORMAT);
1570         std::unique_ptr <IList, _ListPtrUtil::Remover> pIntegerList (GetPropertyListN(operation, _RESULT_INTEGER_LIST), _ListPtrUtil::remover);
1571         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
1572         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
1573
1574         std::unique_ptr <Tizen::Base::Collection::ArrayListT<Tizen::Graphics::PixelFormat>, _ListPtrUtil::Remover> pFormatList (new (std::nothrow) ArrayListT<Tizen::Graphics::PixelFormat>(), _ListPtrUtil::remover);
1575         SysTryReturn(NID_MEDIA, pFormatList.get() != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
1576
1577         r = pFormatList->Construct();
1578         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1579
1580         for (int i = 0; i < pIntegerList->GetCount(); i++)
1581         {
1582                 Object* pObj = null;
1583                 Integer* pInteger = null;
1584                 pObj = pIntegerList->GetAt(i);
1585                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object instance is not available. %d item is not found.", i);
1586
1587                 pInteger = dynamic_cast<Integer*>(pObj);
1588                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's format is invalid.", i);
1589
1590                 r = pFormatList->Add((Tizen::Graphics::PixelFormat)pInteger->ToInt());
1591                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1592                 SysLog(NID_MEDIA, "Pixel format : %d was added.", pInteger->ToInt());
1593         }
1594
1595         return pFormatList.release();
1596
1597 CATCH:
1598         return null;
1599 }
1600
1601 result
1602 _CameraImpl::SetIsoLevel(CameraIsoLevel isoLevel)
1603 {
1604         result r = E_SUCCESS;
1605         CameraState state = CAMERA_STATE_ERROR;
1606         int err = MM_SUCCESS;
1607         _ResultType itemType = _RESULT_INTEGER_LIST;
1608
1609         camera_attr_iso_e attr = ::CAMERA_ATTR_ISO_AUTO;
1610         SysLog(NID_MEDIA, "Enter. isoLevel:%d", isoLevel);
1611
1612         state = GetState();
1613         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1614                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1615
1616         SysTryReturn(NID_MEDIA, isoLevel >= CAMERA_ISO_DEFAULT && isoLevel <= CAMERA_ISO_MAX , E_OUT_OF_RANGE, E_OUT_OF_RANGE
1617                 , "[E_OUT_OF_RANGE] This isoLevel(%d) is out of range.", isoLevel);
1618
1619         if (__isPoweredOn)
1620         {
1621                 _CameraOperationType operation = _COP_NONE;
1622                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_ISO_LEVEL : _COP_SECONDARY_ISO_LEVEL);
1623
1624                 std::unique_ptr <IList, _ListPtrUtil::Remover> pIsoList (GetPropertyListN(operation, itemType), _ListPtrUtil::remover);
1625                 SysTryCatch(NID_MEDIA, pIsoList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The operation:%d is not supported.", operation);
1626                 SysTryCatch(NID_MEDIA, pIsoList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1627                 SysTryCatch(NID_MEDIA, pIsoList->Contains(Integer(isoLevel)) || isoLevel == CAMERA_ISO_DEFAULT || isoLevel == CAMERA_ISO_MIN
1628                          || isoLevel == CAMERA_ISO_MAX, r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This isoLevel(%d) is not supported in the device.\n",  isoLevel);
1629
1630                 if(__sceneMode != CAMERA_SCENE_OFF)
1631                 {//because this attribute is related to scene mode.
1632                         r = SetSceneModeAttr(CAMERA_SCENE_OFF);
1633                         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. ResetSceneMode", GetErrorMessage(r));
1634                 }
1635                 r = _CameraUtil::GetMmIso(isoLevel, attr);
1636                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. isoLevel :%d", GetErrorMessage(r), isoLevel);
1637
1638                 err = camera_attr_set_iso(__handle, attr);
1639                 r = ConvertResult(err);
1640                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. isoLevel :%d", GetErrorMessage(r), isoLevel);
1641         }
1642         __isoLevel = isoLevel;
1643
1644 CATCH:
1645         return r;
1646 }
1647
1648
1649 CameraIsoLevel
1650 _CameraImpl::GetIsoLevel(void) const
1651 {
1652         return __isoLevel;
1653 }
1654
1655 result
1656 _CameraImpl::SetPreviewFrameRate(int fps)
1657 {
1658         result r = E_SUCCESS;
1659         CameraState state = CAMERA_STATE_ERROR;
1660         int err = MM_SUCCESS;
1661         camera_attr_fps_e attr = ::CAMERA_ATTR_FPS_AUTO;
1662         SysLog(NID_MEDIA, "Enter. fps:%d", fps);
1663
1664         state = GetState();
1665         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED, E_INVALID_STATE, E_INVALID_STATE,
1666                 "[E_INVALID_STATE] Camera is in an invalid state. This method is working in CAMERA_STATE_INITIALIZED state. Current state is :%d", (
1667                                         int) state);
1668
1669         std::unique_ptr <IListT<int>, _ListPtrUtil::Remover> pList (GetSupportedPreviewFrameRateListN(), _ListPtrUtil::remover);
1670         SysTryCatch(NID_MEDIA, pList.get() != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Getting the supported list was failed.\n");
1671         SysTryCatch(NID_MEDIA, pList->Contains(fps), r = E_OUT_OF_RANGE, E_OUT_OF_RANGE,
1672                 "[E_OUT_OF_RANGE]. This fps(%d) is out of range.", fps);
1673
1674         r = _CameraUtil::GetMmFps(fps, attr);
1675         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. fps:%d", GetErrorMessage(r), fps);
1676
1677         err = camera_attr_set_preview_fps(__handle, attr);
1678         r = ConvertResult(err);
1679         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1680
1681         __fps = fps;
1682
1683 CATCH:
1684         return r;
1685 }
1686
1687 int
1688 _CameraImpl::GetPreviewFrameRate(void) const
1689 {
1690         return __fps;
1691 }
1692
1693 Tizen::Base::Collection::IListT <int>*
1694 _CameraImpl::GetSupportedPreviewFrameRateListN(void) const
1695 {
1696         result r = E_SUCCESS;
1697         _CameraOperationType operation = _COP_NONE;
1698
1699         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_PREVIEW_FRAMERATE : _COP_SECONDARY_PREVIEW_FRAMERATE);
1700         std::unique_ptr <IList, _ListPtrUtil::Remover> pIntegerList (GetPropertyListN(operation, _RESULT_INTEGER_LIST), _ListPtrUtil::remover);
1701         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
1702         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
1703
1704         std::unique_ptr <Tizen::Base::Collection::ArrayListT<int>, _ListPtrUtil::Remover> pListT (new (std::nothrow) ArrayListT<int>(), _ListPtrUtil::remover);
1705         SysTryReturn(NID_MEDIA, pListT.get() != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
1706
1707         r = pListT->Construct();
1708         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1709
1710         for (int i = 0; i < pIntegerList->GetCount(); i++)
1711         {
1712                 Object* pObj = null;
1713                 Integer* pInteger = null;
1714                 pObj = pIntegerList->GetAt(i);
1715                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object instance is not available. %d item is not found.", i);
1716
1717                 pInteger = dynamic_cast<Integer*>(pObj);
1718                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's fps is invalid.", i);
1719
1720                 r = pListT->Add(pInteger->ToInt());
1721                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1722                 SysLog(NID_MEDIA, "FPS : %d was added.", pInteger->ToInt());
1723         }
1724
1725         return pListT.release();
1726
1727 CATCH:
1728         return null;
1729 }
1730
1731 Tizen::Base::Collection::IListT<int>*
1732 _CameraImpl::GetSupportedPreviewFrameRateListN(const Tizen::Graphics::Dimension& dim) const
1733 {
1734         result r = E_SUCCESS;
1735         Object *pObj = null;
1736         _CameraDeviceType device = _CAMERA_DEVICE_NONE;
1737         _ResultType  itemType = _RESULT_NONE;
1738
1739         device = (__selection == CAMERA_PRIMARY ? _CAMERA_DEVICE_PRIMARY : _CAMERA_DEVICE_SECONDARY);
1740         pObj = _CameraCapability::GetSupportedPreviewFrameRateN(device, _QUERY_LIST, dim, itemType);
1741         std::unique_ptr <ArrayList, _ListPtrUtil::Remover> pIntegerList (dynamic_cast<ArrayList*>(pObj), _ListPtrUtil::remover);
1742         SysTryReturn(NID_MEDIA, pIntegerList.get() != null, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  Supported list was wrong.");
1743         SysTryReturn(NID_MEDIA, pIntegerList->GetCount() > 0, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The list was empty.");
1744
1745         std::unique_ptr <Tizen::Base::Collection::ArrayListT<int>, _ListPtrUtil::Remover> pListT (new (std::nothrow) ArrayListT<int>(), _ListPtrUtil::remover);
1746         SysTryCatch(NID_MEDIA, pListT.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
1747
1748         r = pListT->Construct();
1749         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1750
1751         for (int i = 0; i < pIntegerList->GetCount(); i++)
1752         {
1753                 Object* pObj = null;
1754                 Integer* pInteger = null;
1755                 pObj = pIntegerList->GetAt(i);
1756                 SysTryCatch(NID_MEDIA, pObj != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Object instance is not available. %d item is not found.", i);
1757
1758                 pInteger = dynamic_cast<Integer*>(pObj);
1759                 SysTryCatch(NID_MEDIA, pInteger != null, r = E_INVALID_FORMAT, E_INVALID_FORMAT, "[E_INVALID_FORMAT] %d item's fps is invalid.", i);
1760
1761                 r = pListT->Add(pInteger->ToInt());
1762                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1763                 SysLog(NID_MEDIA, "FPS : %d was added.", pInteger->ToInt());
1764         }
1765
1766         return pListT.release();
1767
1768 CATCH:
1769         return null;
1770 }
1771
1772 result
1773 _CameraImpl::SetExifOrientation(CameraExifOrientation orientation)
1774 {
1775         result r = E_SUCCESS;
1776         CameraState state = CAMERA_STATE_ERROR;
1777         SysLog(NID_MEDIA, "Enter. orientation:%d", orientation);
1778
1779         state = GetState();
1780         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1781                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1782
1783         SysTryCatch(NID_MEDIA, CAMERA_EXIF_ORIENTATION_TOP_LEFT <= orientation && orientation <= CAMERA_EXIF_ORIENTATION_LEFT_BOTTOM,
1784                 r = E_OUT_OF_RANGE, r, "[E_OUT_OF_RANGE]  This orientation(%d) is out of range.", orientation);
1785
1786         if ( __isPoweredOn )
1787         {
1788                 __pCoordinator->SetCameraOrientation(orientation);
1789         }
1790         __exifOrientation = orientation;
1791         return r;
1792
1793 CATCH:
1794         return r;
1795 }
1796
1797 result
1798 _CameraImpl::SetExifGpsCoordinates(double latitude, double longitude, float altitude)
1799 {
1800         result r = E_SUCCESS;
1801         CameraState state = CAMERA_STATE_ERROR;
1802         int err = MM_SUCCESS;
1803         SysLog(NID_MEDIA, "Enter. latitude:%f, longitude:%f, altitude:%f", latitude, longitude, altitude);
1804
1805         state = GetState();
1806         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1807                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1808
1809         SysTryCatch(NID_MEDIA, -90.0 <= latitude && latitude <= 90.0 , r = E_OUT_OF_RANGE, r, "[E_OUT_OF_RANGE] This latitude(%f) is out of range.", latitude);
1810         SysTryCatch(NID_MEDIA, -180.0 <= longitude && longitude <= 180.0 , r = E_OUT_OF_RANGE, r, "[E_OUT_OF_RANGE] This longitude(%f) is out of range.", longitude);
1811
1812         if ( __isPoweredOn )
1813         {
1814                 err = camera_attr_set_geotag(__handle, latitude, longitude, (double)altitude);
1815                 r = ConvertResult(err);
1816                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. latitude:%f, longitude:%f, altitude:%f", GetErrorMessage(r), latitude, longitude, altitude);
1817         }
1818         __exifLatitude = latitude;
1819         __exifLongitude = longitude;
1820         __exifAltitude = altitude;
1821         return r;
1822
1823 CATCH:
1824         return r;
1825 }
1826
1827 result
1828 _CameraImpl::DisableExifGpsCoordinates(void)
1829 {
1830         result r = E_SUCCESS;
1831         CameraState state = CAMERA_STATE_ERROR;
1832         int err = MM_SUCCESS;
1833         SysLog(NID_MEDIA, "Disable exif gps co-ordinates");
1834
1835         state = GetState();
1836         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1837                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. This method is not working in this state. Current state is :%d", state);
1838
1839         err = camera_attr_remove_geotag(__handle);
1840         r = ConvertResult(err);
1841         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1842
1843         __exifLatitude = _CAMERA_EXIF_GPS_INVALID_LATITUDE;
1844         __exifLongitude = _CAMERA_EXIF_GPS_INVALID_LONGITUDE;
1845         __exifAltitude = 0;
1846         return r;
1847
1848 CATCH:
1849         return r;
1850 }
1851
1852 result
1853 _CameraImpl::SetFlip(CameraFlipType flip)
1854 {
1855         result r = E_SUCCESS;
1856         CameraState state = CAMERA_STATE_ERROR;
1857         int err = MM_SUCCESS;
1858         camera_flip_e attr = ::CAMERA_FLIP_NONE;
1859         String key = (__selection == CAMERA_PRIMARY ? CAMERA_PRIMARY_FLIP : CAMERA_SECONDARY_FLIP);
1860         SysLog(NID_MEDIA, "Enter. flip:%d", flip);
1861
1862         state = GetState();
1863         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED, E_INVALID_STATE, E_INVALID_STATE,
1864                 "[E_INVALID_STATE] Camera is in an invalid state. This method is working in CAMERA_STATE_INITIALIZED state. Current state is :%d", state);
1865         SysTryReturn(NID_MEDIA, flip >= CAMERA_FLIP_NONE && flip <= CAMERA_FLIP_VERTICAL , E_INVALID_ARG , E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(flip) is used. flip=%d.", flip);
1866
1867         std::unique_ptr <IList, _ListPtrUtil::Remover> pSupportedList (GetPropertyListN(key), _ListPtrUtil::remover);
1868         SysTryCatch(NID_MEDIA, pSupportedList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1869         SysTryCatch(NID_MEDIA, pSupportedList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1870         SysTryCatch(NID_MEDIA, pSupportedList->Contains(Integer(flip)), r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This flip(%d) is not supported in the device.\n",  flip);
1871
1872         r = _CameraUtil::GetMmFlip(__selection, flip, attr);
1873         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. flip:%d", GetErrorMessage(r), flip);
1874
1875         err = camera_attr_set_stream_flip(__handle, attr);
1876         r = ConvertResult(err);
1877         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. flip:%d", GetErrorMessage(r), flip);
1878
1879         __flip = flip;
1880
1881 CATCH:
1882         return r;
1883 }
1884
1885 CameraFlipType
1886 _CameraImpl::GetFlip(void) const
1887 {
1888         return __flip;
1889 }
1890
1891 result
1892 _CameraImpl::SetPreviewRotation(CameraRotation rotation)
1893 {
1894         result r = E_SUCCESS;
1895         CameraState state = CAMERA_STATE_ERROR;
1896         int err = MM_SUCCESS;
1897         camera_rotation_e attr = ::CAMERA_ROTATION_NONE;
1898         String key = (__selection == CAMERA_PRIMARY ? CAMERA_PRIMARY_PREVIEW_ROTATION : CAMERA_SECONDARY_PREVIEW_ROTATION);
1899         SysLog(NID_MEDIA, "Enter. rotation:%d", rotation);
1900
1901         state = GetState();
1902         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED, E_INVALID_STATE, E_INVALID_STATE,
1903                 "[E_INVALID_STATE] Camera is in an invalid state. This method is working in CAMERA_STATE_INITIALIZED state. Current state is :%d", state);
1904         SysTryReturn(NID_MEDIA, rotation >= CAMERA_ROTATION_NONE && rotation <= CAMERA_ROTATION_270, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(rotation) is used. rotation=%d.", rotation);
1905
1906         std::unique_ptr <IList, _ListPtrUtil::Remover> pSupportedList (GetPropertyListN(key), _ListPtrUtil::remover);
1907         SysTryCatch(NID_MEDIA, pSupportedList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1908         SysTryCatch(NID_MEDIA, pSupportedList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1909         SysTryCatch(NID_MEDIA, pSupportedList->Contains(Integer(rotation)), r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This rotation(%d) is not supported in the device.\n",  rotation);
1910
1911         r = _CameraUtil::GetMmRotation(rotation, attr);
1912         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), rotation);
1913
1914         err = camera_attr_set_stream_rotation(__handle, attr);
1915         r = ConvertResult(err);
1916         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera rotate stream failed. displayHandle:%d, previewedData:%d", GetErrorMessage(r), __previewRegionHandle, __previewProcessing);
1917
1918         __previewRotation = rotation;
1919
1920 CATCH:
1921         return r;
1922 }
1923
1924 CameraRotation
1925 _CameraImpl::GetPreviewRotation(void) const
1926 {
1927         return __previewRotation;
1928 }
1929
1930 result
1931 _CameraImpl::SetMeteringMode(CameraMeteringMode meteringMode)
1932 {
1933         result r = E_SUCCESS;
1934         CameraState state = CAMERA_STATE_ERROR;
1935         int err = MM_SUCCESS;
1936         camera_attr_exposure_mode_e attr = ::CAMERA_ATTR_EXPOSURE_MODE_OFF;
1937         String key = (__selection == CAMERA_PRIMARY ? CAMERA_PRIMARY_METERING_MODE : CAMERA_SECONDARY_METERING_MODE);
1938         SysLog(NID_MEDIA, "Enter. meteringMode:%d", meteringMode);
1939
1940         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera was not powered on.");
1941
1942         state = GetState();
1943         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1944                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] This method is not working in this state. Current state is :%d", state);
1945         SysTryReturn(NID_MEDIA, meteringMode >= CAMERA_METERING_MODE_NONE, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] This mode %d cannot be set.", meteringMode);
1946
1947         std::unique_ptr <IList, _ListPtrUtil::Remover> pSupportedList (GetPropertyListN(key), _ListPtrUtil::remover);
1948         SysTryCatch(NID_MEDIA, pSupportedList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1949         SysTryCatch(NID_MEDIA, pSupportedList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1950         SysTryCatch(NID_MEDIA, pSupportedList->Contains(Integer(meteringMode)) || meteringMode == CAMERA_METERING_MODE_NONE
1951                 , r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This mode(%d) is not supported in the device.\n",  meteringMode);
1952
1953         if(__sceneMode != CAMERA_SCENE_OFF)
1954         {//because this attribute is related to scene mode.
1955                 r = SetSceneModeAttr(CAMERA_SCENE_OFF);
1956                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. ResetSceneMode", GetErrorMessage(r));
1957         }
1958         r = _CameraUtil::GetMmMeteringMode(meteringMode, attr);
1959         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), meteringMode);
1960
1961         err = camera_attr_set_exposure_mode(__handle, attr);
1962         r = ConvertResult(err);
1963         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera metering mode failed. meteringMode:%d", GetErrorMessage(r), meteringMode);
1964
1965         __meteringMode = meteringMode;
1966
1967 CATCH:
1968         return r;
1969 }
1970
1971 CameraMeteringMode
1972 _CameraImpl::GetMeteringMode(void) const
1973 {
1974         return __meteringMode;
1975 }
1976
1977 result
1978 _CameraImpl::SetSceneMode(CameraSceneMode sceneMode)
1979 {
1980         result r = E_SUCCESS;
1981         CameraState state = CAMERA_STATE_ERROR;
1982         int err = MM_SUCCESS;
1983         camera_attr_scene_mode_e attr = ::CAMERA_ATTR_SCENE_MODE_NORMAL;
1984         SysLog(NID_MEDIA, "Enter. sceneMode:%d", sceneMode);
1985
1986         SysTryReturn(NID_MEDIA, __isPoweredOn == true, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Camera was not powered on.");
1987
1988         state = GetState();
1989         SysTryReturn(NID_MEDIA, state == CAMERA_STATE_INITIALIZED || state == CAMERA_STATE_PREVIEW || state == CAMERA_STATE_CAPTURED
1990                 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] This method is not working in this state. Current state is :%d", state);
1991         SysTryReturn(NID_MEDIA, sceneMode >= CAMERA_SCENE_OFF, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] This mode %d cannot be set.", sceneMode);
1992
1993         _CameraOperationType operation = _COP_NONE;
1994         _ResultType itemType = _RESULT_INTEGER_LIST;
1995         operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_SCENE_MODE : _COP_SECONDARY_SCENE_MODE);
1996         std::unique_ptr <IList, _ListPtrUtil::Remover> pSceneModeList (GetPropertyListN(operation, itemType), _ListPtrUtil::remover);
1997         SysTryCatch(NID_MEDIA, pSceneModeList.get() != null, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
1998
1999         SysTryCatch(NID_MEDIA, pSceneModeList->GetCount() > 0, r = E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION]");
2000         SysTryCatch(NID_MEDIA, pSceneModeList->Contains(Integer(sceneMode))
2001                 , r = E_UNSUPPORTED_TYPE, E_UNSUPPORTED_TYPE, "[E_UNSUPPORTED_TYPE]. This mode(%d) is not supported in the device.\n",  sceneMode);
2002
2003         r = _CameraUtil::GetMmSceneMode(sceneMode, attr);
2004         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. sceneMode:%d", GetErrorMessage(r), sceneMode);
2005
2006         err = camera_attr_set_scene_mode(__handle, attr);
2007         r = ConvertResult(err);
2008         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera scene mode failed. sceneMode:%d", GetErrorMessage(r), sceneMode);
2009
2010         if ((sceneMode == CAMERA_SCENE_OFF) && (__sceneMode != CAMERA_SCENE_OFF))
2011         {
2012                 __sceneMode = sceneMode;
2013                 r = ReloadConfiguration(_RELOAD_BRIGHTNESS  | _RELOAD_WB  |  _RELOAD_ISO  | _RELOAD_METERING_MODE | _RELOAD_FOCUS_MODE | _RELOAD_FLASH);
2014                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating", GetErrorMessage(r));
2015         }
2016         else
2017         {
2018                 __sceneMode = sceneMode;
2019         }
2020 CATCH:
2021         return r;
2022 }
2023
2024 CameraSceneMode
2025 _CameraImpl::GetSceneMode(void) const
2026 {
2027         return __sceneMode;
2028 }
2029
2030 result
2031 _CameraImpl::SetSceneModeAttr(CameraSceneMode sceneMode)
2032 {
2033         result r = E_SUCCESS;
2034         int err = MM_SUCCESS;
2035         camera_attr_scene_mode_e attr = ::CAMERA_ATTR_SCENE_MODE_NORMAL;
2036
2037         r = _CameraUtil::GetMmSceneMode(sceneMode, attr);
2038         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. sceneMode:%d", GetErrorMessage(r), sceneMode);
2039
2040         err = camera_attr_set_scene_mode(__handle, attr);
2041         r = ConvertResult(err);
2042         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera scene mode failed. sceneMode:%d", GetErrorMessage(r), sceneMode);
2043         __sceneMode = sceneMode;
2044
2045         if(sceneMode == CAMERA_SCENE_OFF)
2046         {
2047                 r = ReloadConfiguration(_RELOAD_BRIGHTNESS  | _RELOAD_WB  |  _RELOAD_ISO  | _RELOAD_METERING_MODE | _RELOAD_FOCUS_MODE | _RELOAD_FLASH);
2048                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating", GetErrorMessage(r));
2049         }
2050 CATCH:
2051         return r;
2052 }
2053
2054 result
2055 _CameraImpl::AddVideoStreamFilter(IVideoStreamFilter& filter)
2056 {
2057         result r = E_SUCCESS;
2058
2059         r = __pVideoStreamCoordinator->AddVideoStreamFilter(filter);
2060         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating", GetErrorMessage(r));
2061
2062         __previewProcessing = __previewProcessing | _PREVIEW_PRE_PROCESSING;
2063
2064         return r;
2065 }
2066
2067 result
2068 _CameraImpl::RemoveVideoStreamFilter(IVideoStreamFilter& filter)
2069 {
2070         result r = E_SUCCESS;
2071
2072         r = __pVideoStreamCoordinator->RemoveVideoStreamFilter(filter);
2073         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating", GetErrorMessage(r));
2074
2075         if (__pVideoStreamCoordinator->GetFilterListCount() == 0)
2076         {
2077                 __previewProcessing = __previewProcessing & (~_PREVIEW_PRE_PROCESSING);
2078         }
2079
2080         return r;
2081 }
2082
2083 result
2084 _CameraImpl::ConvertResult(int err) const
2085 {
2086         result r = E_SYSTEM;
2087         if (err != ::CAMERA_ERROR_NONE)
2088         {
2089                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
2090         }
2091
2092         // Global error
2093         if (err == ::CAMERA_ERROR_NONE)
2094         {
2095                 r = E_SUCCESS;
2096         }
2097         else if (err == ::CAMERA_ERROR_INVALID_PARAMETER)
2098         {
2099                 r = E_INVALID_ARG;
2100         }
2101         else if (err == ::CAMERA_ERROR_INVALID_STATE)
2102         {
2103                 r = E_INVALID_STATE;
2104         }
2105         else if (err == ::CAMERA_ERROR_OUT_OF_MEMORY)
2106         {
2107                 r = E_OUT_OF_MEMORY;
2108         }
2109         else if (err == ::CAMERA_ERROR_DEVICE)
2110         {
2111                 r = E_DEVICE_FAILED;
2112         }
2113         else if (err == ::CAMERA_ERROR_INVALID_OPERATION
2114                         || err == ::CAMERA_ERROR_SECURITY_RESTRICTED)
2115         {
2116                 r = E_SYSTEM;
2117         }
2118         else if (err == ::CAMERA_ERROR_DEVICE_BUSY
2119                         || err == ::CAMERA_ERROR_SOUND_POLICY)
2120         {
2121                 r = E_DEVICE_BUSY;
2122         }
2123         else if (err == ::CAMERA_ERROR_DEVICE_NOT_FOUND)
2124         {
2125                 r = E_DEVICE_UNAVAILABLE;
2126         }
2127         else
2128         {
2129                 r = E_UNKNOWN;
2130         }
2131
2132         return r;
2133 }
2134
2135 camera_state_e
2136 _CameraImpl::GetMmState(void) const
2137 {
2138         result r = E_SUCCESS;
2139         int err = MM_SUCCESS;
2140         camera_state_e mmState = ::CAMERA_STATE_NONE;
2141
2142         err = camera_get_state(__handle, &mmState);
2143         r = ConvertResult(err);
2144         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2145
2146         return mmState;
2147
2148 CATCH:
2149         return ::CAMERA_STATE_NONE;
2150 }
2151
2152 void
2153 _CameraImpl::SetState(CameraState state)
2154 {
2155         __state = state;
2156 }
2157
2158 CameraSelection
2159 _CameraImpl::GetSelection(void) const
2160 {
2161         return __selection;
2162 }
2163
2164 result
2165 _CameraImpl::EnqueueData(_CameraBuffer& cameraBuffer)
2166 {
2167         result r = E_SUCCESS;
2168         _CameraBufferType bufferType = cameraBuffer.GetBufferType();
2169         SysTryReturn(NID_MEDIA, cameraBuffer.GetLimit() > 0, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] Propagating. bufferType:%d", GetErrorMessage(r), bufferType);
2170
2171         std::unique_ptr <_CameraBuffer> pCameraBuffer (new (std::nothrow) _CameraBuffer());
2172         SysTryReturn(NID_MEDIA, pCameraBuffer.get() != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
2173
2174         r = pCameraBuffer->Construct(cameraBuffer);
2175         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. bufferType:%d", GetErrorMessage(r), bufferType);
2176
2177         switch (bufferType)
2178         {
2179         case _CAMERA_BUFFER_CAPTURE:
2180                 r = __pCaptureBufferQueue->Enqueue(*pCameraBuffer.get());
2181                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. bufferType:%d", GetErrorMessage(r), bufferType);
2182                 break;
2183
2184         case _CAMERA_BUFFER_PREVIEW:
2185                 r = __pPreviewBufferQueue->Enqueue(*pCameraBuffer.get());
2186                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. bufferType:%d", GetErrorMessage(r), bufferType);
2187                 break;
2188
2189         default:
2190                 r = E_INVALID_ARG;
2191                 SysLogException(NID_MEDIA, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(bufferType) is used. bufferType=%d.", bufferType);
2192                 break;
2193         }
2194
2195         pCameraBuffer.release();
2196         return r;
2197 }
2198
2199
2200 _CameraBuffer*
2201 _CameraImpl::DequeueDataN(_CameraBufferType bufferType)
2202 {
2203         result r = E_SUCCESS;
2204         _CameraBuffer* pBuffer = null;
2205
2206         switch (bufferType)
2207         {
2208         case _CAMERA_BUFFER_CAPTURE:
2209                 pBuffer = static_cast<_CameraBuffer*>(__pCaptureBufferQueue->Dequeue());
2210                 break;
2211
2212         case _CAMERA_BUFFER_PREVIEW:
2213                 pBuffer = static_cast<_CameraBuffer*>(__pPreviewBufferQueue->Dequeue());
2214                 break;
2215
2216         case _CAMERA_BUFFER_NONE:
2217         default:
2218                 break;
2219         }
2220         SysTryCatch(NID_MEDIA, pBuffer != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] Propagating. bufferType:%d", GetErrorMessage(E_OBJ_NOT_FOUND), bufferType);
2221
2222         return pBuffer;
2223
2224 CATCH:
2225         SysLogException(NID_MEDIA, E_UNDERFLOW, "[E_UNDERFLOW] Queue is empty.");
2226         return null;
2227 }
2228
2229 _CameraCoordinator*
2230 _CameraImpl::GetCoordinator(void)
2231 {
2232         return __pCoordinator;
2233 }
2234
2235 bool
2236 _CameraImpl::IsZeroShutterLag(void) const
2237 {
2238         return __zeroShutterLag;
2239 }
2240
2241 Tizen::Graphics::PixelFormat
2242 _CameraImpl::GetDeviceRecommendPreviewFormat(void) const
2243 {
2244         return __deviceDefaultPreviewFormat;
2245 }
2246
2247 result
2248 _CameraImpl::SetProperty(_CameraOperationType operation, int min, int max, int value)
2249 {
2250         result r = E_SUCCESS;
2251         bool supported = false;
2252         int mmMin = 0;
2253         int mmMax = 0;
2254         int mmValue = 0;
2255         int err = MM_SUCCESS;
2256
2257         SysLog(NID_MEDIA, "Enter. operation:%d, min:%d, max:%d, value:%d", operation, min, max, value);
2258
2259         SysTryReturn(NID_MEDIA, max - min > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(Min, Max) is used. Min:%d, Max:%d wrong. value is :%d", min, max, value);
2260         SysTryReturn(NID_MEDIA, value >= min && value <= max, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(Min, Max) is used. Min:%d, Max:%d value is :%d", min, max, value);
2261
2262         supported = _CameraCapability::IsSupported(operation);
2263         SysTryReturn(NID_MEDIA, supported == true, E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The operation:%d is not supported.", operation);
2264
2265         switch (operation)
2266         {
2267         case _COP_PRIMARY_BRIGHTNESS:
2268         case _COP_SECONDARY_BRIGHTNESS:
2269                 err = camera_attr_get_brightness_range(__handle, &mmMin, &mmMax);
2270                 r = ConvertResult(err);
2271                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera get attribute range failed. operation:%d, value:%d", GetErrorMessage(r), operation, value);
2272
2273                 mmValue = (int) ((double) (mmMax - mmMin) / (double) (max - min) * (double) value);
2274                 if (mmValue < mmMin)
2275                 {
2276                         mmValue = mmMin;
2277                 }
2278                 else if (mmValue > mmMax)
2279                 {
2280                         mmValue = mmMax;
2281                 }
2282                 err = camera_attr_set_brightness(__handle, mmValue);
2283                 r = ConvertResult(err);
2284                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera set attribute range failed. operation:%d, value:%d, mmValue:%d", GetErrorMessage(r), operation, value, mmValue);
2285                 break;
2286
2287         case _COP_PRIMARY_CONTRAST:
2288         case _COP_SECONDARY_CONTRAST:
2289                 err = camera_attr_get_contrast_range(__handle, &mmMin, &mmMax);
2290                 r = ConvertResult(err);
2291                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera get attribute range failed. operation:%d, value:%d", GetErrorMessage(r), operation, value);
2292
2293                 mmValue = (int) ((double) (mmMax - mmMin) / (double) (max - min) * (double) value);
2294                 if (mmValue < mmMin)
2295                 {
2296                         mmValue = mmMin;
2297                 }
2298                 else if (mmValue > mmMax)
2299                 {
2300                         mmValue = mmMax;
2301                 }
2302                 err = camera_attr_set_contrast(__handle, mmValue);
2303                 r = ConvertResult(err);
2304                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera set attribute range failed. operation:%d, value:%d, mmValue:%d", GetErrorMessage(r), operation, value, mmValue);
2305                 break;
2306
2307         case _COP_PRIMARY_EXPOSURE:
2308         case _COP_SECONDARY_EXPOSURE:
2309                 err = camera_attr_get_exposure_range(__handle, &mmMin, &mmMax);
2310                 r = ConvertResult(err);
2311                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera get attribute range failed. operation:%d, value:%d", GetErrorMessage(r), operation, value);
2312
2313                 mmValue = (int) ((double) (mmMax - mmMin) / (double) (max - min) * (double) value);
2314                 if (mmValue < mmMin)
2315                 {
2316                         mmValue = mmMin;
2317                 }
2318                 else if (mmValue > mmMax)
2319                 {
2320                         mmValue = mmMax;
2321                 }
2322                 err = camera_attr_set_exposure(__handle, mmValue);
2323                 r = ConvertResult(err);
2324                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera set attribute range failed. operation:%d, value:%d, mmValue:%d", GetErrorMessage(r), operation, value, mmValue);
2325                 break;
2326
2327         case _COP_PRIMARY_ZOOM_LEVEL:
2328         case _COP_SECONDARY_ZOOM_LEVEL:
2329                 err = camera_attr_get_zoom_range(__handle, &mmMin, &mmMax);
2330                 r = ConvertResult(err);
2331                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera get attribute range failed. operation:%d, value:%d", GetErrorMessage(r), operation, value);
2332
2333                 mmValue = (int) ((double) (mmMax - mmMin) / (double) (max - min) * (double) value);
2334                 if (mmValue < mmMin)
2335                 {
2336                         mmValue = mmMin;
2337                 }
2338                 else if (mmValue > mmMax)
2339                 {
2340                         mmValue = mmMax;
2341                 }
2342                 err = camera_attr_set_zoom(__handle, mmValue);
2343                 r = ConvertResult(err);
2344                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera set attribute range failed. operation:%d, value:%d, mmValue:%d", GetErrorMessage(r), operation, value, mmValue);
2345                 break;
2346
2347         default:
2348                 break;
2349         }
2350         return r;
2351
2352 CATCH:
2353         return r;
2354 }
2355
2356 result
2357 _CameraImpl::GetProperty(_CameraOperationType operation, int& mmMin, int& mmMax) const
2358 {
2359         result r = E_SUCCESS;
2360         int err = MM_SUCCESS;
2361
2362         switch (operation)
2363         {
2364         case _COP_PRIMARY_ZOOM_LEVEL:
2365         case _COP_SECONDARY_ZOOM_LEVEL:
2366                 err = camera_attr_get_zoom_range(__handle, &mmMin, &mmMax);
2367                 r = ConvertResult(err);
2368                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera get attribute range failed. operation:%d", GetErrorMessage(r), operation);
2369                 break;
2370
2371         default:
2372                 break;
2373         }
2374         return r;
2375
2376 CATCH:
2377         return r;
2378 }
2379
2380 Tizen::Base::Collection::IList*
2381 _CameraImpl::GetPropertyListN(_CameraOperationType operation, _ResultType itemQueryType) const
2382 {
2383         result r = E_SUCCESS;
2384         _ResultType itemType = _RESULT_NONE;
2385
2386         std::unique_ptr <IList, _ListPtrUtil::Remover> pList (_CameraCapability::GetListN(operation, itemType), _ListPtrUtil::remover);
2387         SysTryCatch(NID_MEDIA, pList.get() != null, , GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
2388         SysTryCatch(NID_MEDIA, itemType == itemQueryType, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  itemQueryType%d, itemType:%d are not same", itemQueryType, itemType);
2389
2390         return pList.release();
2391
2392 CATCH:
2393         return null;
2394 }
2395
2396 Tizen::Base::Collection::IList*
2397 _CameraImpl::GetPropertyListN(const Tizen::Base::String& key) const
2398 {
2399         result r = E_SUCCESS;
2400         _CapabilityImpl* pCapability = null;
2401
2402         std::unique_ptr <ArrayList, _ListPtrUtil::Remover> pList (new (std::nothrow) ArrayList(), _ListPtrUtil::remover);
2403         SysTryCatch(NID_MEDIA, pList.get() != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
2404
2405         r = pList->Construct();
2406         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2407
2408         pCapability = _CapabilityImpl::GetInstance();
2409         SysTryCatch(NID_MEDIA, pCapability != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _CapabilityImpl instance is not available.");
2410         r = pCapability->GetValueN(key, *(pList.get()));                //TODO check
2411         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2412
2413         return pList.release();
2414
2415 CATCH:
2416         return null;
2417 }
2418
2419 result
2420 _CameraImpl::ReloadConfiguration(int reload)
2421 {
2422         result r = E_SUCCESS;
2423         int err = MM_SUCCESS;
2424         SysLog(NID_MEDIA, "Enter. reload:0x%x", reload);
2425
2426         if (reload & _RELOAD_PREVIEW_RESOLUTION)
2427         {
2428                 err = camera_set_preview_resolution(__handle, __previewResolution.width, __previewResolution.height);
2429                 r = ConvertResult(err);
2430                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
2431         }
2432         if (reload & _RELOAD_CAPTURE_RESOLUTION)
2433         {
2434                 err = camera_set_capture_resolution(__handle, __captureResolution.width, __captureResolution.height);
2435                 r = ConvertResult(err);
2436                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
2437         }
2438         if (reload & _RELOAD_PREVIEW_FORMAT)
2439         {
2440                 camera_pixel_format_e attr = ::CAMERA_PIXEL_FORMAT_INVALID;
2441                 r = _CameraUtil::GetMmPixelFormat(__previewFormat, attr);
2442                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. pixel format:%d", GetErrorMessage(r), __previewFormat);
2443
2444                 err = camera_set_preview_format(__handle, attr);
2445                 r = ConvertResult(err);
2446                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
2447         }
2448         if (reload & _RELOAD_INTERNAL_PREVIEW_FORMAT)
2449         {
2450                 err = camera_set_preview_format(__handle, __pCoordinator->GetReloadPreviewFormat());
2451                 r = ConvertResult(err);
2452                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
2453         }
2454         if (reload & _RELOAD_CAPTURE_FORMAT)
2455         {
2456                 camera_pixel_format_e attr = ::CAMERA_PIXEL_FORMAT_INVALID;
2457                 r = _CameraUtil::GetMmPixelFormat(__captureFormat, attr);
2458                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. pixel format:%d", GetErrorMessage(r), __captureFormat);
2459
2460                 err = camera_set_capture_format(__handle, attr);
2461                 r = ConvertResult(err);
2462                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2463         }
2464         if (reload & _RELOAD_FPS)
2465         {
2466                 camera_attr_fps_e attr = ::CAMERA_ATTR_FPS_AUTO;
2467                 r = _CameraUtil::GetMmFps(__fps, attr);
2468                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. fps:%d", GetErrorMessage(r), __fps);
2469
2470                 err = camera_attr_set_preview_fps(__handle, attr);
2471                 r = ConvertResult(err);
2472                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2473         }
2474         if (reload & _RELOAD_BRIGHTNESS)
2475         {
2476                 _CameraOperationType operation = _COP_NONE;
2477                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_BRIGHTNESS : _COP_SECONDARY_BRIGHTNESS);
2478                 if ( _CameraCapability::IsSupported(operation))
2479                 {
2480                         r = SetProperty(operation, _MIN_PROPERTY, _MAX_PROPERTY, __brightness);
2481                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2482                 }
2483         }
2484         if (reload & _RELOAD_CONTRAST)
2485         {
2486                 _CameraOperationType operation = _COP_NONE;
2487                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_CONTRAST : _COP_SECONDARY_CONTRAST);
2488                 if ( _CameraCapability::IsSupported(operation))
2489                 {
2490                         r = SetProperty(operation, _MIN_PROPERTY, _MAX_PROPERTY, __contrast);
2491                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2492                 }
2493         }
2494         if (reload & _RELOAD_EXPOSURE)
2495         {
2496                 _CameraOperationType operation = _COP_NONE;
2497                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_EXPOSURE : _COP_SECONDARY_EXPOSURE);
2498                 if ( _CameraCapability::IsSupported(operation))
2499                 {
2500                         r = SetProperty(operation, _MIN_PROPERTY, _MAX_PROPERTY, __exposure);
2501                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2502                 }
2503         }
2504         if (reload & _RELOAD_MAX_ZOOM_LEVEL)
2505         {
2506                 _CameraOperationType operation = _COP_NONE;
2507                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_ZOOM_LEVEL : _COP_SECONDARY_ZOOM_LEVEL);
2508                 int minZoom = 0;
2509                 int maxZoom = 0;
2510                 if ( _CameraCapability::IsSupported(operation))
2511                 {
2512                         r = GetProperty(operation, minZoom, maxZoom);
2513                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2514                 }
2515                 __maxZoomLevel = maxZoom - minZoom;
2516         }
2517         if (reload & _RELOAD_ZOOM_LEVEL)
2518         {
2519                 _CameraOperationType operation = _COP_NONE;
2520                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_ZOOM_LEVEL : _COP_SECONDARY_ZOOM_LEVEL);
2521                 if ( _CameraCapability::IsSupported(operation))
2522                 {
2523                         int zoomLevel = 0;
2524                         while (zoomLevel < __zoomLevel)
2525                         {
2526                                 zoomLevel++;
2527                                 r = SetProperty(operation, __minZoomLevel, __maxZoomLevel, zoomLevel);
2528                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2529                         }
2530                 }
2531         }
2532         if (reload & _RELOAD_EFFECT)
2533         {
2534                 _CameraOperationType operation = _COP_NONE;
2535                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_EFFECT : _COP_SECONDARY_EFFECT);
2536                 if ( _CameraCapability::IsSupported(operation))
2537                 {
2538                         camera_attr_effect_mode_e attr = ::CAMERA_ATTR_EFFECT_NONE;
2539                         r = _CameraUtil::GetMmEffect(__effect, attr);
2540                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. effect:%d", GetErrorMessage(r), __effect);
2541
2542                         err = camera_attr_set_effect(__handle, attr);
2543                         r = ConvertResult(err);
2544                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2545                 }
2546         }
2547         if (reload & _RELOAD_WB)
2548         {
2549                 _CameraOperationType operation = _COP_NONE;
2550                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_WHITE_BALANCE : _COP_SECONDARY_WHITE_BALANCE);
2551                 if ( _CameraCapability::IsSupported(operation))
2552                 {
2553                         camera_attr_whitebalance_e attr = ::CAMERA_ATTR_WHITE_BALANCE_NONE;
2554                         r = _CameraUtil::GetMmWhiteBalance(__wb, attr);
2555                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. whiteBalance:%d", GetErrorMessage(r), __wb);
2556
2557                         err = camera_attr_set_whitebalance(__handle, attr);
2558                         r = ConvertResult(err);
2559                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2560                 }
2561         }
2562         if ((reload & _RELOAD_QUALITY) && (__quality != CAMERA_QUALITY_NORMAL))
2563         {
2564                 int attr = 0;
2565                 r = _CameraUtil::GetMmQuality(__quality, attr);
2566                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. quality:%d", GetErrorMessage(r), __quality);
2567
2568                 err = camera_attr_set_image_quality(__handle, attr);
2569                 r = ConvertResult(err);
2570                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2571         }
2572         if (reload & _RELOAD_ISO)
2573         {
2574                 _CameraOperationType operation = _COP_NONE;
2575                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_ISO_LEVEL : _COP_SECONDARY_ISO_LEVEL);
2576                 if ( _CameraCapability::IsSupported(operation))
2577                 {
2578                         camera_attr_iso_e attr = ::CAMERA_ATTR_ISO_AUTO;
2579
2580                         r = _CameraUtil::GetMmIso(__isoLevel, attr);
2581                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. iso:%d", GetErrorMessage(r), __isoLevel);
2582
2583                         err = camera_attr_set_iso(__handle, attr);
2584                         r = ConvertResult(err);
2585                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2586                 }
2587         }
2588         if ((reload & _RELOAD_EXIF_ORIENTATION) && (__exifOrientation != CAMERA_EXIF_ORIENTATION_NONE))         //TODO check whether the exif data is lasting or one-time.
2589         {
2590                 __pCoordinator->SetCameraOrientation(__exifOrientation);
2591         }
2592         if (reload & _RELOAD_EXIF_GPS_COORDINATES)
2593         {
2594                 if ( __exifLatitude < _CAMERA_EXIF_GPS_INVALID_LATITUDE && __exifLongitude < _CAMERA_EXIF_GPS_INVALID_LONGITUDE )
2595                 {
2596                         err = camera_attr_set_geotag(__handle, __exifLatitude, __exifLongitude, (double)__exifAltitude);
2597                         r = ConvertResult(err);
2598                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2599                 }
2600                 else
2601                 {
2602                         err = camera_attr_remove_geotag(__handle);
2603                         r = ConvertResult(err);
2604                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2605                 }
2606         }
2607         if (reload & _RELOAD_FLASH)
2608         {
2609                 _CameraOperationType operation = _COP_NONE;
2610                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_FLASH_MODE : _COP_SECONDARY_FLASH_MODE);
2611
2612                 if ( _CameraCapability::IsSupported(operation))
2613                 {
2614                         camera_attr_flash_mode_e attr = ::CAMERA_ATTR_FLASH_MODE_OFF;
2615                         r = _CameraUtil::GetMmFlashMode(__flashMode, attr);
2616
2617                         err = camera_attr_set_flash_mode(__handle, attr);
2618                         r = ConvertResult(err);
2619                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2620                 }
2621         }
2622         if (reload & _RELOAD_FLIP)      // Flip shoud be called before rotation set.
2623         {
2624                 String key = (__selection == CAMERA_PRIMARY ? CAMERA_PRIMARY_FLIP : CAMERA_SECONDARY_FLIP);
2625                 std::unique_ptr <IList, _ListPtrUtil::Remover> pSupportedList (GetPropertyListN(key), _ListPtrUtil::remover);
2626
2627                 if (pSupportedList.get() != null)
2628                 {
2629                         if (pSupportedList->GetCount() > 0)
2630                         {
2631                                 camera_flip_e attr = ::CAMERA_FLIP_NONE;
2632                                 r = _CameraUtil::GetMmFlip(__selection, __flip, attr);
2633                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. flip:%d", GetErrorMessage(r), __flip);
2634
2635                                 err = camera_attr_set_stream_flip(__handle, attr);
2636                                 r = ConvertResult(err);
2637                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2638                         }
2639                 }
2640         }
2641         if (reload & _RELOAD_PREVIEW_ROTATION)
2642         {
2643                 String key = (__selection == CAMERA_PRIMARY ? CAMERA_PRIMARY_PREVIEW_ROTATION : CAMERA_SECONDARY_PREVIEW_ROTATION);
2644                 std::unique_ptr <IList, _ListPtrUtil::Remover> pSupportedList (GetPropertyListN(key), _ListPtrUtil::remover);
2645
2646                 if (pSupportedList.get() != null)
2647                 {
2648                         if (pSupportedList->GetCount() > 0)
2649                         {
2650                                 camera_rotation_e attr = ::CAMERA_ROTATION_NONE;
2651                                 r = _CameraUtil::GetMmRotation(__previewRotation, attr);
2652                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), __previewRotation);
2653
2654                                 err = camera_attr_set_stream_rotation(__handle, attr);
2655                                 r = ConvertResult(err);
2656                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2657                         }
2658                 }
2659         }
2660         if (reload & _RELOAD_PREVIEW_PREPARE)
2661         {
2662                 if ((__previewProcessing & _PREVIEW_PRE_PROCESSING) || (__previewProcessing & _PREVIEW_POST_PROCESSING))
2663                 {
2664                         err = camera_set_preview_cb(__handle, PreviewCb, this);
2665                 }
2666                 else
2667                 {
2668                         err = camera_unset_preview_cb(__handle);
2669                 }
2670                 r = ConvertResult(err);
2671                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Preview callback setting failed. Process:%b", GetErrorMessage(r), __previewProcessing);
2672
2673                 if ( __previewRegionHandle != _BufferInfoImpl::INVALID_BUFFER_HANDLE )
2674                 {
2675                         err = camera_set_display(__handle, __previewDisplayType, (camera_display_h)__previewRegionHandle);
2676                         r = ConvertResult(err);
2677                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera set display failed. displayHandle:%d, Process:%b",
2678                                 GetErrorMessage(r), __previewRegionHandle, __previewProcessing);
2679
2680                         if ( __previewDisplayType == ::CAMERA_DISPLAY_TYPE_X11 )
2681                         {
2682                                 err = camera_set_x11_display_mode(__handle, ::CAMERA_DISPLAY_MODE_FULL);
2683                                 r = ConvertResult(err);
2684                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera set display mode failed. displayHandle:%d, Process:%b",
2685                                         GetErrorMessage(r), __previewRegionHandle, __previewProcessing);
2686
2687                                 err = camera_set_x11_display_visible(__handle, true);
2688                                 r = ConvertResult(err);
2689                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera enabling display visible failed. displayHandle:%d, Process:%b",
2690                                         GetErrorMessage(r), __previewRegionHandle, __previewProcessing);
2691                                 /*
2692                                 camera_rotation_e attr = ::CAMERA_ROTATION_NONE;
2693                                 r = _CameraUtil::GetMmRotation(__displayRotationType, attr);
2694                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2695
2696                                 err = camera_set_x11_display_rotation(__handle, attr);
2697                                 r = ConvertResult(err);
2698                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera rotate display failed. displayHandle:%d, Process:%b, __displayRotationType:%d",
2699                                         GetErrorMessage(r), __previewRegionHandle, __previewProcessing, __displayRotationType);
2700                                 */
2701                         }
2702                 }
2703                 else
2704                 {
2705                         err = camera_set_display(__handle, ::CAMERA_DISPLAY_TYPE_NONE, null);
2706                         r = ConvertResult(err);
2707                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera set display(null) failed. Process:%b", GetErrorMessage(r), __previewProcessing);
2708                 }
2709         }
2710         if (reload & _RELOAD_FOCUS_MODE)
2711         {
2712                 _CameraOperationType operation = _COP_NONE;
2713                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_FOCUS_MODE : _COP_SECONDARY_FOCUS_MODE);
2714
2715                 if ( _CameraCapability::IsSupported(operation))
2716                 {
2717                         r = ChangeFocusModeTo(__focusMode, __focusMode);
2718                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. focus mode is %d", GetErrorMessage(r), __focusMode);
2719                 }
2720         }
2721         if (reload & _RELOAD_METERING_MODE)
2722         {
2723                 _CameraOperationType operation = _COP_NONE;
2724                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_METERING_MODE : _COP_SECONDARY_METERING_MODE);
2725
2726                 if ( _CameraCapability::IsSupported(operation))
2727                 {
2728                         camera_attr_exposure_mode_e attr = ::CAMERA_ATTR_EXPOSURE_MODE_OFF;
2729                         r = _CameraUtil::GetMmMeteringMode(__meteringMode, attr);
2730                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. metering:%d", GetErrorMessage(r), __meteringMode);
2731
2732                         err = camera_attr_set_exposure_mode(__handle, attr);
2733                         r = ConvertResult(err);
2734                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. metering:%d", GetErrorMessage(r), __meteringMode);
2735                 }
2736         }
2737         if (reload & _RELOAD_SCENE_MODE)
2738         {
2739                 _CameraOperationType operation = _COP_NONE;
2740                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_SCENE_MODE : _COP_SECONDARY_SCENE_MODE);
2741
2742                 if ( _CameraCapability::IsSupported(operation))
2743                 {
2744                         camera_attr_scene_mode_e attr = ::CAMERA_ATTR_SCENE_MODE_NORMAL;
2745                         r = _CameraUtil::GetMmSceneMode(__sceneMode, attr);
2746                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. scenemode:%d", GetErrorMessage(r), __sceneMode);
2747
2748                         err = camera_attr_set_scene_mode(__handle, attr);
2749                         r = ConvertResult(err);
2750                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. scenemode:%d", GetErrorMessage(r), __sceneMode);
2751                 }
2752         }
2753         if (reload & _RELOAD_EXTRA)
2754         {
2755                 err = camera_attr_enable_tag(__handle, true);
2756                 r = ConvertResult(err);
2757                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] camera enabling tag failed.", GetErrorMessage(r));
2758         }
2759         return r;
2760
2761 CATCH:
2762         return r;
2763 }
2764
2765 result
2766 _CameraImpl::LoadDefaultConfiguration(int reload)
2767 {
2768         result r = E_SUCCESS;
2769         SysLog(NID_MEDIA, "Enter.");
2770
2771         // Preview resolution
2772         if (reload & _RELOAD_PREVIEW_RESOLUTION)
2773         {
2774                 _CameraOperationType operation = _COP_NONE;
2775                 _ResultType itemType = _RESULT_NONE;
2776                 Dimension* pDim = null;
2777
2778                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_PREVIEW_RESOLUTION : _COP_SECONDARY_PREVIEW_RESOLUTION);
2779                 std::unique_ptr <Object> pObj (_CameraCapability::GetValueN(operation, _QUERY_DEFAULT_VALUE, itemType));
2780                 SysTryReturn(NID_MEDIA, itemType == _RESULT_DIMENSION, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The type is wrong. itemType:%d", itemType);
2781                 pDim = dynamic_cast<Dimension*>(pObj.get());
2782                 SysTryReturn(NID_MEDIA, pDim != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The preview resolution is wrong.");
2783                 __deviceDefaultPreviewResolution = *pDim;
2784                 __previewResolution = __deviceDefaultPreviewResolution;
2785         }
2786
2787         // Capture resolution
2788         if (reload & _RELOAD_CAPTURE_RESOLUTION)
2789         {
2790                 _CameraOperationType operation = _COP_NONE;
2791                 _ResultType itemType = _RESULT_NONE;
2792                 Dimension* pDim = null;
2793
2794                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_CAPTURE_RESOLUTION : _COP_SECONDARY_CAPTURE_RESOLUTION);
2795                 std::unique_ptr <Object> pObj (_CameraCapability::GetValueN(operation, _QUERY_DEFAULT_VALUE, itemType));
2796                 SysTryReturn(NID_MEDIA, itemType == _RESULT_DIMENSION, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The type is wrong. itemType:%d", itemType);
2797                 pDim = dynamic_cast<Dimension*>(pObj.get());
2798                 SysTryReturn(NID_MEDIA, pDim != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The capture resolution is wrong.");
2799                 __deviceDefaultCaptureResolution = *pDim;
2800                 __captureResolution = __deviceDefaultCaptureResolution;
2801         }
2802
2803         // Preview format
2804         if (reload & _RELOAD_PREVIEW_FORMAT)
2805         {
2806                 _CameraOperationType operation = _COP_NONE;
2807                 _ResultType itemType = _RESULT_NONE;
2808                 Integer *pInteger = null;
2809
2810                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_PREVIEW_FORMAT : _COP_SECONDARY_PREVIEW_FORMAT);
2811                 std::unique_ptr <Object> pObj (_CameraCapability::GetValueN(operation, _QUERY_DEFAULT_VALUE, itemType));
2812                 SysTryReturn(NID_MEDIA, itemType == _RESULT_INTEGER, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The type is wrong. itemType:%d", itemType);
2813                 pInteger = dynamic_cast<Integer*>(pObj.get());
2814                 SysTryReturn(NID_MEDIA, pInteger != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The preview format is wrong.");
2815                 __deviceDefaultPreviewFormat = (Tizen::Graphics::PixelFormat)pInteger->ToInt();
2816                 __previewFormat = __deviceDefaultPreviewFormat;
2817         }
2818
2819         // Capture format
2820         if (reload & _RELOAD_CAPTURE_FORMAT)
2821         {
2822                 _CameraOperationType operation = _COP_NONE;
2823                 _ResultType itemType = _RESULT_NONE;
2824                 Integer *pInteger = null;
2825
2826                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_CAPTURE_FORMAT : _COP_SECONDARY_CAPTURE_FORMAT);
2827                 std::unique_ptr <Object> pObj (_CameraCapability::GetValueN(operation, _QUERY_DEFAULT_VALUE, itemType));
2828                 SysTryReturn(NID_MEDIA, itemType == _RESULT_INTEGER, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The type is wrong. itemType:%d", itemType);
2829                 pInteger = dynamic_cast<Integer*>(pObj.get());
2830                 SysTryReturn(NID_MEDIA, pInteger != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The capture format is wrong.");
2831                 __deviceDefaultCaptureFormat = (Tizen::Graphics::PixelFormat)pInteger->ToInt();
2832                 __captureFormat = __deviceDefaultCaptureFormat;
2833         }
2834
2835         // Focus mode
2836         if (reload & _RELOAD_FOCUS_MODE)
2837         {
2838                 String key = (__selection == CAMERA_PRIMARY ? CAMERA_PRIMARY_FOCUS_MODE : CAMERA_SECONDARY_FOCUS_MODE);
2839                 std::unique_ptr <IList, _ListPtrUtil::Remover> pSupportedList (GetPropertyListN(key), _ListPtrUtil::remover);
2840
2841                 if (pSupportedList.get() != null)
2842                 {
2843                         if (pSupportedList->GetCount() > 0)
2844                         {
2845                                 __focusMode = CAMERA_FOCUS_MODE_NORMAL;
2846                         }
2847                 }
2848                 else
2849                 {
2850                         __focusMode = CAMERA_FOCUS_MODE_NONE;
2851                 }
2852         }
2853
2854         // Zero shutter lag
2855         if (reload & _RELOAD_ZERO_SHUTTER_LAG)
2856         {
2857                 _CameraOperationType operation = _COP_NONE;
2858                 _ResultType itemType = _RESULT_NONE;
2859                 Integer *pInteger = null;
2860
2861                 operation = (__selection == CAMERA_PRIMARY ? _COP_PRIMARY_ZERO_SHUTTER_LAG: _COP_SECONDARY_ZERO_SHUTTER_LAG);
2862                 std::unique_ptr <Object> pObj (_CameraCapability::GetValueN(operation, _QUERY_DEFAULT_VALUE, itemType));
2863                 SysTryReturn(NID_MEDIA, itemType == _RESULT_INTEGER, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The type is wrong. itemType:%d", itemType);
2864                 pInteger = dynamic_cast<Integer*>(pObj.get());
2865                 SysTryReturn(NID_MEDIA, pInteger != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.  The zero shutter lag value is wrong.");
2866                 __zeroShutterLag = (bool)pInteger->ToInt();
2867         }
2868
2869         //Metering mode
2870         if (reload & _RELOAD_METERING_MODE)
2871         {
2872                 String key = (__selection == CAMERA_PRIMARY ? CAMERA_PRIMARY_METERING_MODE : CAMERA_SECONDARY_METERING_MODE);
2873                 std::unique_ptr <IList, _ListPtrUtil::Remover> pSupportedList (GetPropertyListN(key), _ListPtrUtil::remover);
2874
2875                 if (pSupportedList.get() != null)
2876                 {
2877                         if (pSupportedList->GetCount() > 0)
2878                         {
2879                                 __meteringMode = CAMERA_METERING_MODE_AVERAGE;
2880                         }
2881                 }
2882                 else
2883                 {
2884                         __meteringMode = CAMERA_METERING_MODE_NONE;
2885                 }
2886         }
2887
2888         return r;
2889 }
2890
2891 result
2892 _CameraImpl::ChangeFocusModeTo(CameraFocusMode currentMode, CameraFocusMode destMode)
2893 {
2894         result r = E_SUCCESS;
2895         int tableTotalCount = 0;
2896         int i = 0;
2897         int err = MM_SUCCESS;
2898
2899         tableTotalCount = sizeof(_CAMERA_FOCUS_MODE_TRANSIT) / sizeof(_CAMERA_FOCUS_MODE_TRANSIT[0]);
2900         SysLog(NID_MEDIA, " currentMode:%d, destMode:%d, tableTotalCount:%d", currentMode, destMode, tableTotalCount);
2901
2902         for (i = 0; i < tableTotalCount; i++)
2903         {
2904                 if (currentMode == _CAMERA_FOCUS_MODE_TRANSIT[i].currentMode && destMode == _CAMERA_FOCUS_MODE_TRANSIT[i].destMode)
2905                 {
2906                         SysLog(NID_MEDIA, "Exist the matching mode field. loop i:%d, current mode:%d, destMode:%d, operation0:%d", i, currentMode, destMode, _CAMERA_FOCUS_MODE_TRANSIT[i].focusOperation0);
2907                         switch (_CAMERA_FOCUS_MODE_TRANSIT[i].focusOperation0)
2908                         {
2909                         case _FOCUS_MODE_OP_NONE:
2910                                 break;
2911                         case _FOCUS_MODE_OP_CONTINUOUS:
2912                                 break;
2913                         case _FOCUS_MODE_OP_CANCEL:
2914                                 err = camera_cancel_focusing(__handle);
2915                                 r = ConvertResult(err);
2916                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to cancel focus.", GetErrorMessage(r));
2917                                 break;
2918                         default:
2919                                 break;
2920                         }
2921
2922                         // Set the mm's focus mode.
2923                         camera_attr_af_mode_e attr = ::CAMERA_ATTR_AF_NONE;
2924                         r = _CameraUtil::GetMmFocusMode(destMode, attr);
2925                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. focus mode:%d", GetErrorMessage(r), destMode);
2926
2927                         err = camera_attr_set_af_mode (__handle, attr);
2928                         r = ConvertResult(err);
2929                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to set the focus mode", GetErrorMessage(r));
2930
2931                         switch (_CAMERA_FOCUS_MODE_TRANSIT[i].focusOperation1)
2932                         {
2933                         case _FOCUS_MODE_OP_NONE:
2934                                 break;
2935                         case _FOCUS_MODE_OP_CONTINUOUS:
2936                                 err = camera_start_focusing(__handle, true);
2937                                 r = ConvertResult(err);
2938                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to start continuous focusing", GetErrorMessage(r));
2939                                 break;
2940                         case _FOCUS_MODE_OP_CANCEL:
2941                                 break;
2942                         default:
2943                                 break;
2944                         }
2945                         break;
2946                 }
2947         }
2948         SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
2949         return r;
2950
2951 CATCH:
2952         SysLog(NID_MEDIA, "[%s] Real currentMode:%d, param destMode:%d", GetErrorMessage(r), currentMode, destMode);
2953         return r;
2954 }
2955
2956 result
2957 _CameraImpl::HandleAutoFocus(CameraFocusMode currentMode)
2958 {
2959         result r = E_SUCCESS;
2960         int tableTotalCount = 0;
2961         int i = 0;
2962         int err = MM_SUCCESS;
2963
2964         tableTotalCount = sizeof(_CAMERA_FOCUS_OPERATIONT) / sizeof(_CAMERA_FOCUS_OPERATIONT[0]);
2965         SysLog(NID_MEDIA, "Current mode:%d", currentMode);
2966
2967         for (i = 0; i < tableTotalCount; i++)
2968         {
2969                 if (currentMode == _CAMERA_FOCUS_OPERATIONT[i].currentMode)
2970                 {
2971                         SysLog(NID_MEDIA, "Exist the matching mode field. loop i:%d, current mode:%d, operation:%d", i, currentMode, _CAMERA_FOCUS_OPERATIONT[i].focusOperation);
2972                         switch (_CAMERA_FOCUS_OPERATIONT[i].focusOperation)
2973                         {
2974                         case _FOCUS_OP_NONE:
2975                                 break;
2976                         case _FOCUS_OP_ONCE:
2977                                 err = camera_start_focusing(__handle, false);
2978                                 r = ConvertResult(err);
2979                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Failed to start focus once.", GetErrorMessage(r));
2980                                 break;
2981                         default:
2982                                 break;
2983                         }
2984
2985                         if (_CAMERA_FOCUS_OPERATIONT[i].state >= CAMERA_STATE_INITIALIZED && _CAMERA_FOCUS_OPERATIONT[i].state <= CAMERA_STATE_ERROR)
2986                         {
2987                                 SetState(_CAMERA_FOCUS_OPERATIONT[i].state);
2988                                 SysLog(NID_MEDIA, "Set the state to %d", _CAMERA_FOCUS_OPERATIONT[i].state);
2989                         }
2990                         break;
2991                 }
2992         }
2993         SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
2994         return r;
2995
2996 CATCH:
2997         SysLog(NID_MEDIA, "[%s] Current mode:%d", GetErrorMessage(r), currentMode);
2998         return r;
2999 }
3000
3001 result
3002 _CameraImpl::OnCameraCoordinatorModeChangePrepared(_CameraMode mode)
3003 {
3004         result r = E_SUCCESS;
3005         SysLog(NID_MEDIA, "Mode:%d", mode);
3006
3007         r = ReloadConfiguration(_RELOAD_PREVIEW_RESOLUTION  | _RELOAD_CAPTURE_RESOLUTION  | _RELOAD_INTERNAL_PREVIEW_FORMAT
3008                 | _RELOAD_CAPTURE_FORMAT  | _RELOAD_FPS  |  _RELOAD_FLIP  | _RELOAD_PREVIEW_ROTATION  | _RELOAD_PREVIEW_PREPARE);
3009         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating", GetErrorMessage(r));
3010
3011         SysLog(NID_MEDIA, "Pre mode changed operation succeeded.");
3012         return r;
3013 }
3014
3015 result
3016 _CameraImpl::OnCameraCoordinatorModeChanged(_CameraMode mode)
3017 {
3018         result r = E_SUCCESS;
3019         SysLog(NID_MEDIA, "Mode:%d", mode);
3020
3021         if (__sceneMode == CAMERA_SCENE_OFF)
3022         {
3023                 r = ReloadConfiguration(_RELOAD_BRIGHTNESS  | _RELOAD_WB  |  _RELOAD_ISO  | _RELOAD_METERING_MODE | _RELOAD_FLASH  | _RELOAD_FOCUS_MODE );
3024                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating", GetErrorMessage(r));
3025         }
3026
3027         r = ReloadConfiguration(_RELOAD_CONTRAST  | _RELOAD_EXPOSURE  | _RELOAD_MAX_ZOOM_LEVEL  | _RELOAD_ZOOM_LEVEL  | _RELOAD_EFFECT
3028                 | _RELOAD_QUALITY  | _RELOAD_EXIF_ORIENTATION  | _RELOAD_EXIF_GPS_COORDINATES
3029                 | _RELOAD_SCENE_MODE  | _RELOAD_EXTRA);
3030         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating", GetErrorMessage(r));
3031
3032         SysLog(NID_MEDIA, "Post mode changed operation succeeded.");
3033         return r;
3034 }
3035
3036 void
3037 _CameraImpl::StateChangedCb(camera_state_e previous, camera_state_e current, bool byPolicy, void *pUserData)
3038 {
3039         _CameraImpl* pImpl = static_cast<_CameraImpl*>( pUserData);
3040         SysTryReturnVoidResult(NID_MEDIA, _CameraImpl::IsAlive(), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
3041         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[%s] _CameraImpl instance is not available.", GetErrorMessage(E_OBJ_NOT_FOUND));
3042         SysLog(NID_MEDIA, "State previous:%d, current:%d, byPolicy:%d", previous, current, byPolicy);
3043 }
3044
3045 void
3046 _CameraImpl::CaptureCb(camera_image_data_s* pImage, camera_image_data_s *pPostview, camera_image_data_s* pThumbnail, void* pUserData)
3047 {
3048         result r = E_SUCCESS;
3049         _CameraImpl* pImpl = static_cast<_CameraImpl*>(pUserData);
3050         MediaPixelFormat format = MEDIA_PIXEL_FORMAT_NONE;
3051         double ratio = 0.0;
3052         SysTryReturnVoidResult(NID_MEDIA, _CameraImpl::IsAlive(), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
3053         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _CameraImpl is null.");
3054         SysTryReturnVoidResult(NID_MEDIA, pImpl->GetState() == CAMERA_STATE_CAPTURING, E_INVALID_STATE, "[E_INVALID_STATE] The camera is already capturing");
3055         SysTryCatch(NID_MEDIA, pImage != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] image is null.");
3056         SysLog(NID_MEDIA, "Enter. image size:%d, format:%d", pImage->size, pImage->format);
3057
3058         _CameraUtil::GetOspMediaPixelFormat(pImage->format, format, ratio);
3059         if (format == MEDIA_PIXEL_FORMAT_NONE)          // if the encoded data
3060         {
3061                 _CameraBuffer cameraBuffer;
3062                 CodecType codec = CODEC_NONE;
3063
3064                 _CameraUtil::GetOspCodecType(pImage->format, codec);
3065                 r = cameraBuffer.Construct(pImage->size, _CAMERA_BUFFER_CAPTURE, codec, true, pImage->width, pImage->height);
3066                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d, format%d", GetErrorMessage(r), pImage->size, pImage->format);
3067
3068                 r = cameraBuffer.SetArray((byte*) pImage->data, 0, pImage->size);
3069                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. data:%d, size:%d", GetErrorMessage(r), (int) pImage->data, pImage->size);
3070                 cameraBuffer.Flip();
3071
3072                 r = pImpl->EnqueueData(cameraBuffer);
3073                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. data:%d, size:%d", GetErrorMessage(r), (int) pImage->data, pImage->size);
3074         }
3075         else            // if the raw data
3076         {
3077                 _CameraBuffer cameraBuffer;
3078
3079                 r = cameraBuffer.Construct(pImage->size, _CAMERA_BUFFER_CAPTURE, format, pImage->width, pImage->height);
3080                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d, format%d", GetErrorMessage(r), pImage->size, pImage->format);
3081
3082                 r = cameraBuffer.SetArray((byte*) pImage->data, 0, pImage->size);
3083                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. data:%d, size:%d", GetErrorMessage(r), (int) pImage->data, pImage->size);
3084                 cameraBuffer.Flip();
3085
3086                 r = pImpl->EnqueueData(cameraBuffer);
3087                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. data:%d, size:%d", GetErrorMessage(r), (int) pImage->data, pImage->size);
3088         }
3089
3090         return;
3091 CATCH:
3092         SysLogException(NID_MEDIA, E_INVALID_DATA, "[E_INVALID_DATA] Invalid data is captured.");
3093         return;
3094 }
3095
3096 void
3097 _CameraImpl::CaptureCompletedCb(void *pUserData)
3098 {
3099         result r = E_SUCCESS;
3100         _CameraImpl* pImpl = static_cast<_CameraImpl*>(pUserData);
3101         SysLog(NID_MEDIA, "CaptureCompletedCb");
3102
3103         SysTryReturnVoidResult(NID_MEDIA, _CameraImpl::IsAlive(), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
3104         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _CameraImpl instance is not available.");
3105
3106         std::unique_ptr <ByteBuffer> pBuffer (pImpl->DequeueDataN(_CAMERA_BUFFER_CAPTURE));
3107         if (pBuffer.get() != null)
3108         {
3109                 SysLog(NID_MEDIA, "Captured data sending. size is %d", pBuffer->GetLimit());
3110                 if (pBuffer->GetLimit() > 0)
3111                 {
3112                         r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_CAPTURED, CAMERA_ERROR_NONE, E_SUCCESS, pBuffer.release());
3113                         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
3114                 }
3115                 else
3116                 {
3117                         SysLogException(NID_MEDIA, E_INVALID_DATA, "[E_INVALID_DATA] The captured data is invalid.");
3118                         r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_CAPTURED, CAMERA_ERROR_DEVICE_FAILED, E_INVALID_DATA, pBuffer.release());
3119                         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
3120                 }
3121         }
3122         else
3123         {
3124                 SysLogException(NID_MEDIA, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Out of memory for capturing anymore.");
3125                 r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_CAPTURED, CAMERA_ERROR_OUT_OF_MEMORY, E_OUT_OF_MEMORY, null);
3126                 SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
3127         }
3128
3129         return;
3130 }
3131
3132 void
3133 _CameraImpl::PreviewCb(camera_preview_data_s *pFrame, void *pUserData)
3134 {
3135         result r = E_SUCCESS;
3136         int queueCount = 0;
3137         _CameraImpl* pImpl = static_cast<_CameraImpl*>(pUserData);
3138
3139         SysTryReturnVoidResult(NID_MEDIA, _CameraImpl::IsAlive(), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
3140         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _CameraImpl instance is not available.");
3141         SysTryReturnVoidResult(NID_MEDIA, pFrame != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] camera_preview_data_s instance is not available.");
3142         SysLog(NID_MEDIA, "Enter. preview format:%d, width:%d, height:%d, num_of_planes:%d", pFrame->format, pFrame->width, pFrame->height, pFrame->num_of_planes);
3143
3144         queueCount = pImpl->__pPreviewBufferQueue->GetCount();
3145         if (queueCount < _MAX_PREVIEW_BUFFER_COUNT)
3146         {
3147                 int previewProcessing = pImpl->__previewProcessing;
3148                 if (previewProcessing & _PREVIEW_PRE_PROCESSING)
3149                 {
3150                         //for Preprocessing
3151                         int size[MAX_CAMERA_PLANE_COUNT] = {0,};
3152                         byte* data[MAX_CAMERA_PLANE_COUNT] = {0,};
3153                         VideoPlaneType planeType[MAX_CAMERA_PLANE_COUNT] = {VIDEO_PLANE_TYPE_NONE,};
3154                         if (pFrame->num_of_planes == 1)
3155                         {
3156                                 size[0] = pFrame->data.single_plane.size;
3157                                 data[0] = pFrame->data.single_plane.yuv;
3158                                 planeType[0] = VIDEO_PLANE_TYPE_YUV;
3159
3160                         }
3161                         else if (pFrame->num_of_planes == 2)
3162                         {
3163                                 size[0] = pFrame->data.double_plane.y_size;
3164                                 size[1] = pFrame->data.double_plane.uv_size;
3165                                 data[0] = pFrame->data.double_plane.y;
3166                                 data[1] = pFrame->data.double_plane.uv;
3167                                 planeType[0] = VIDEO_PLANE_TYPE_Y;
3168                                 planeType[1] = VIDEO_PLANE_TYPE_UV;
3169                         }
3170                         else if (pFrame->num_of_planes == 3)
3171                         {
3172                                 size[0] = pFrame->data.triple_plane.y_size;
3173                                 size[1] = pFrame->data.triple_plane.u_size;
3174                                 size[2] = pFrame->data.triple_plane.v_size;
3175                                 data[0] = pFrame->data.triple_plane.y;
3176                                 data[1] = pFrame->data.triple_plane.u;
3177                                 data[2] = pFrame->data.triple_plane.v;
3178                                 planeType[0] = VIDEO_PLANE_TYPE_Y;
3179                                 planeType[1] = VIDEO_PLANE_TYPE_U;
3180                                 planeType[2] = VIDEO_PLANE_TYPE_V;
3181                         }
3182                         MediaPixelFormat mediaFormat = MEDIA_PIXEL_FORMAT_NONE;
3183                         double ratio = 0.0;
3184                         _CameraUtil::GetOspMediaPixelFormat(pFrame->format, mediaFormat, ratio);
3185
3186                         r = pImpl->__pVideoStreamCoordinator->ProcessVideoStreamData(mediaFormat, pFrame->width, pFrame->height, pFrame->num_of_planes, data, size, planeType);
3187                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. mediaFormat:%d, plane count:%d, width:%d, height:%d, size:%d"
3188                                 , GetErrorMessage(r), mediaFormat, pFrame->num_of_planes, pFrame->width, pFrame->height, size);
3189                 }
3190
3191                 if (previewProcessing & _PREVIEW_POST_PROCESSING)
3192                 {
3193                         int mmPreviewSize = 0;
3194                         _CameraBuffer mmCameraBuffer;
3195                         MediaPixelFormat format = MEDIA_PIXEL_FORMAT_NONE;
3196                         double ratio = 0.0;
3197
3198                         _CameraUtil::GetOspMediaPixelFormat(pFrame->format, format, ratio);
3199
3200                         if (pFrame->num_of_planes == 1)
3201                         {
3202                                 int yuvSize = pFrame->data.single_plane.size;
3203                                 mmPreviewSize = yuvSize;
3204
3205                                 r = mmCameraBuffer.Construct( yuvSize, _CAMERA_BUFFER_PREVIEW, format, pFrame->width, pFrame->height);
3206                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), mmPreviewSize);
3207
3208                                 r = mmCameraBuffer.SetArray((byte*)pFrame->data.single_plane.yuv, 0, yuvSize);
3209                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), mmPreviewSize);
3210
3211                                 mmCameraBuffer.Flip();
3212                         }
3213                         else if (pFrame->num_of_planes == 2)
3214                         {
3215                                 int ySize = pFrame->data.double_plane.y_size;
3216                                 int uvSize = pFrame->data.double_plane.uv_size;
3217                                 mmPreviewSize = ySize + uvSize;
3218
3219                                 r = mmCameraBuffer.Construct(mmPreviewSize, _CAMERA_BUFFER_PREVIEW, format, pFrame->width, pFrame->height);
3220                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), mmPreviewSize);
3221
3222                                 r = mmCameraBuffer.SetArray((byte*)pFrame->data.double_plane.y, 0, ySize);
3223                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), ySize);
3224
3225                                 r = mmCameraBuffer.SetArray((byte*)pFrame->data.double_plane.uv, 0, uvSize);
3226                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), uvSize);
3227
3228                                 mmCameraBuffer.Flip();
3229                         }
3230                         else if (pFrame->num_of_planes == 3)
3231                         {
3232                                 int ySize = pFrame->data.triple_plane.y_size;
3233                                 int uSize = pFrame->data.triple_plane.u_size;
3234                                 int vSize = pFrame->data.triple_plane.v_size;
3235                                 mmPreviewSize = ySize + uSize + vSize;
3236
3237                                 r = mmCameraBuffer.Construct(mmPreviewSize, _CAMERA_BUFFER_PREVIEW, format, pFrame->width, pFrame->height);
3238                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), mmPreviewSize);
3239
3240                                 r = mmCameraBuffer.SetArray((byte*)pFrame->data.triple_plane.y, 0, ySize);
3241                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), ySize);
3242
3243                                 r = mmCameraBuffer.SetArray((byte*)pFrame->data.triple_plane.u, 0, uSize);
3244                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), uSize);
3245
3246                                 r = mmCameraBuffer.SetArray((byte*)pFrame->data.triple_plane.v, 0, vSize);
3247                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), vSize);
3248
3249                                 mmCameraBuffer.Flip();
3250                         }
3251
3252                         r = pImpl->EnqueueData(mmCameraBuffer);
3253                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. size:%d", GetErrorMessage(r), mmPreviewSize);
3254
3255                         r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_PREVIEWED_DATA, CAMERA_ERROR_NONE, E_SUCCESS, null);         // For the performance, we don't copy the preview data to the event argument.
3256                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
3257                 }
3258         }
3259         return;
3260
3261 CATCH:
3262         SysLogException(NID_MEDIA, E_INVALID_DATA, "[E_INVALID_DATA] Invalid data is streamed..");
3263         if (queueCount < pImpl->__pPreviewBufferQueue->GetCount())        // if the queue is increased.
3264         {
3265                 std::unique_ptr <ByteBuffer> pBuffer (pImpl->DequeueDataN(_CAMERA_BUFFER_PREVIEW));
3266                 pBuffer.reset(null);
3267         }
3268         return;
3269 }
3270
3271 void
3272 _CameraImpl::InterruptedCb(camera_policy_e policy, camera_state_e previous, camera_state_e current, void *pUserData)
3273 {
3274         result r = E_SUCCESS;
3275         _CameraImpl* pImpl = static_cast<_CameraImpl*>(pUserData);
3276         SysLog(NID_MEDIA, "InterruptedCb called, policy is %d, previous state is %d, current state is %d, pUserData address is %x  ", policy, previous, current, pUserData );
3277         SysTryReturnVoidResult(NID_MEDIA, _CameraImpl::IsAlive(), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
3278         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _CameraImpl instance is not available.");
3279         SysTryReturnVoidResult(NID_MEDIA, pImpl->IsPoweredOn() == true, E_INVALID_OPERATION  ,"The camera is already power-offed");
3280         r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_ERROR, CAMERA_ERROR_DEVICE_INTERRUPTED, E_DEVICE_FAILED, null);
3281         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "Sending camera interrupted failed [%s] .", GetErrorMessage(r));
3282 CATCH:
3283         return;
3284 }
3285
3286 void
3287 _CameraImpl::ErrorCb(camera_error_e error, camera_state_e current, void *pUserData)
3288 {
3289         result r = E_SUCCESS;
3290         _CameraImpl* pImpl = static_cast<_CameraImpl*>(pUserData);
3291         SysLog(NID_MEDIA, "ErrorCb called, error is 0x%x, current state is %d, pUserData address is %x  ", error, current, pUserData );
3292         SysTryReturnVoidResult(NID_MEDIA, _CameraImpl::IsAlive(), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
3293         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _CameraImpl instance is not available.");
3294         switch (error)
3295         {
3296         case ::CAMERA_ERROR_OUT_OF_MEMORY:
3297                 r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_ERROR, CAMERA_ERROR_OUT_OF_MEMORY, E_DEVICE_FAILED, null);
3298                 break;
3299         case ::CAMERA_ERROR_DEVICE:
3300                 //fall through
3301         case ::CAMERA_ERROR_DEVICE_BUSY:
3302                 //fall through
3303         case ::CAMERA_ERROR_DEVICE_NOT_FOUND:
3304                 r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_ERROR, CAMERA_ERROR_DEVICE_FAILED, E_DEVICE_FAILED, null);
3305                 break;
3306         default:
3307                 r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_ERROR, CAMERA_ERROR_DEVICE_FAILED, E_DEVICE_FAILED, null);
3308                 break;
3309         }
3310         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "Sending camera error failed [%s] .", GetErrorMessage(r));
3311 CATCH:
3312         return;
3313 }
3314
3315 void
3316 _CameraImpl::FocusStateChangedCb(camera_focus_state_e state, void *pUserData)
3317 {
3318         result r = E_SUCCESS;
3319         _CameraImpl* pImpl = static_cast<_CameraImpl*>(pUserData);
3320         CameraErrorReason cameraErrorReason = CAMERA_ERROR_NONE;
3321         result cameraResult = E_SUCCESS;
3322         SysLog(NID_MEDIA, "Enter. state is %d.", state);
3323         SysTryReturnVoidResult(NID_MEDIA, _CameraImpl::IsAlive(), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The object was already destroyed.");
3324         SysTryReturnVoidResult(NID_MEDIA, pImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _CameraImpl instance is not available.");
3325
3326         CameraFocusMode focusMode = pImpl->GetFocusMode();
3327
3328         switch (state)
3329         {
3330         case ::CAMERA_FOCUS_STATE_ONGOING:
3331                 if (pImpl->ReadyToAutoFocusCallback())
3332                 {
3333                         if (focusMode == CAMERA_FOCUS_MODE_CONTINUOUS_AUTO)
3334                         {
3335                                 cameraErrorReason = CAMERA_ERROR_NONE;
3336                                 cameraResult = E_OPERATION_CANCELED;
3337                                 r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_AUTO_FOCUSED, cameraErrorReason, cameraResult, null);
3338                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
3339                         }
3340                 }
3341                 break;
3342         case ::CAMERA_FOCUS_STATE_RELEASED:
3343                 break;
3344         case ::CAMERA_FOCUS_STATE_FAILED:
3345                 cameraErrorReason = CAMERA_ERROR_DEVICE_FAILED;
3346                 cameraResult = E_DEVICE_FAILED;
3347                 if (pImpl->ReadyToAutoFocusCallback())
3348                 {
3349                         r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_AUTO_FOCUSED, cameraErrorReason, cameraResult, null);
3350                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
3351                 }
3352                 else            // No auto focus event is fired.
3353                 {
3354                         if (pImpl->GetState() == CAMERA_STATE_AUTO_FOCUSING)
3355                         {
3356                                 pImpl->SetState(CAMERA_STATE_PREVIEW);
3357                         }
3358                 }
3359                 break;
3360         case ::CAMERA_FOCUS_STATE_FOCUSED:
3361                 if (pImpl->ReadyToAutoFocusCallback())
3362                 {
3363                         r = pImpl->__pCameraEvent->SendEvent(_CAMERA_EVENT_AUTO_FOCUSED, cameraErrorReason, cameraResult, null);
3364                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
3365                 }
3366                 else            // No auto focus event is fired.
3367                 {
3368                         if (pImpl->GetState() == CAMERA_STATE_AUTO_FOCUSING)
3369                         {
3370                                 pImpl->SetState(CAMERA_STATE_PREVIEW);
3371                         }
3372                 }
3373                 break;
3374
3375         default:
3376                 break;
3377         }
3378
3379 CATCH:
3380         return;
3381 }
3382
3383 bool
3384 _CameraImpl::IsAlive(void)
3385 {
3386         return __isUsed;
3387 }
3388
3389 _CameraImpl*
3390 _CameraImpl::GetInstance(Camera *pCamera)
3391 {
3392         if ( pCamera != null)
3393         {
3394                 return pCamera->__pImpl;
3395         }
3396         return null;
3397 }
3398
3399 const _CameraImpl*
3400 _CameraImpl::GetInstance(const Camera *pCamera)
3401 {
3402         if ( pCamera != null)
3403         {
3404                 return pCamera->__pImpl;
3405         }
3406         return null;
3407 }
3408
3409 }}   // Tizen::Media