src/FMedia_CameraImpl.cpp

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