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