src/FMedia_CameraCoordinator.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_CameraCoordinator.cpp
  20  * @brief                       This file contains the implementation of the %FMedia_CameraCoordinator class.
  21  *
  22  */
  23 #include <FBaseSysLog.h>
  24 #include "FMedia_CameraManager.h"
  25 #include "FMedia_RecorderManager.h"
  26 #include "FMedia_CameraCoordinator.h"
  27 #include "FMedia_ICameraCoordinatorListener.h"
  28 #include "FMedia_CameraUtil.h"
  29 #include "FMedia_RecorderUtil.h"
  30
  31 //#define _VIDEO_RECORDER_ROTATION_
  32
  33 using namespace Tizen::Base;
  34 using namespace Tizen::Base::Collection;
  35
  36 namespace Tizen { namespace Media
  37 {
  38 static const int _ORIENTATION_FOR_RECORDING = 0x1;
  39 static const int _ORIENTATION_FOR_CAMERA = 0x1 << 1;
  40
  41 typedef int (*_CameraFunc)(_CameraHandle mmHandle);
  42
  43 typedef struct
  44 {
  45         camera_state_e prevState;
  46         camera_state_e postState;
  47         _CameraFunc pFunc;
  48 }_CameraStateTransitTable;
  49
  50 static const _CameraStateTransitTable _CAMERA_STATE_TRANSIT[] =
  51 {
  52         {::CAMERA_STATE_CREATED, ::CAMERA_STATE_PREVIEW, camera_start_preview },
  53         {::CAMERA_STATE_CAPTURED, ::CAMERA_STATE_PREVIEW, camera_start_preview },
  54         {::CAMERA_STATE_CAPTURED, ::CAMERA_STATE_CREATED, camera_stop_preview },
  55         {::CAMERA_STATE_PREVIEW, ::CAMERA_STATE_CREATED, camera_stop_preview },
  56 };
  57
  58 typedef int (*_RecorderFunc)(_RecorderHandle mmHandle);
  59
  60 typedef struct
  61 {
  62         recorder_state_e prevState;
  63         recorder_state_e postState;
  64         _RecorderFunc pFunc;
  65 }_RecorderStateTransitTable;
  66
  67 static const _RecorderStateTransitTable _RECORDER_STATE_TRANSIT[] =
  68 {
  69         {::RECORDER_STATE_CREATED, ::RECORDER_STATE_READY, recorder_prepare },
  70         {::RECORDER_STATE_READY, ::RECORDER_STATE_RECORDING, recorder_start },
  71         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_PAUSED, recorder_pause },
  72         {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, recorder_commit },
  73 //      {::RECORDER_STATE_RECORDING, ::RECORDER_STATE_READY, recorder_cancel },
  74         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_READY, recorder_commit },
  75         {::RECORDER_STATE_PAUSED, ::RECORDER_STATE_READY, recorder_cancel },
  76         {::RECORDER_STATE_READY, ::RECORDER_STATE_CREATED, recorder_unprepare },
  77 };
  78
  79 _CameraCoordinatorSafeHashMapT* _CameraCoordinator::__pMap = null;
  80
  81 _CameraCoordinatorSafeHashMapT::_CameraCoordinatorSafeHashMapT(void)
  82 {
  83 }
  84
  85 _CameraCoordinatorSafeHashMapT::~_CameraCoordinatorSafeHashMapT(void)
  86 {
  87         RemoveItems();
  88         _CameraCoordinator::__pMap = null;
  89 }
  90
  91 void
  92 _CameraCoordinatorSafeHashMapT::RemoveItems(void)
  93 {
  94         _CameraCoordinator* pCoordinator = null;
  95         result r = E_SUCCESS;
  96
  97         std::unique_ptr <IListT <_CameraDeviceType>, _ListPtrUtil::Remover> pList (GetKeysN(), _ListPtrUtil::remover);
  98         SysTryReturnVoidResult(NID_MEDIA, pList.get() != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] There is no instance.");
  99         for (int i = 0; i < GetCount(); i++)
 100         {
 101                 _CameraDeviceType deviceType = _CAMERA_DEVICE_NONE;
 102                 r = pList->GetAt(i, deviceType);
 103                 if (IsFailed(r) && deviceType == _CAMERA_DEVICE_NONE)
 104                 {
 105                         continue;
 106                 }
 107
 108                 r = GetValue(deviceType, pCoordinator);
 109                 if (IsFailed(r) && pCoordinator == null)
 110                 {
 111                         continue;
 112                 }
 113                 delete pCoordinator;
 114         }
 115 }
 116
 117 _CameraCoordinator::_CameraCoordinator()
 118         : __cameraDevice(_CAMERA_DEVICE_NONE)
 119         , __cameraHandle(MM_INVALID_HANDLE)
 120         , __recorderHandle(MM_INVALID_HANDLE)
 121         , __mode(_CAMERA_MODE_NONE)
 122         , __pListenerList(null, _ListPtrUtil::remover)
 123         , __orientationFlag(0)
 124         , __cameraOrientation(CAMERA_EXIF_ORIENTATION_TOP_LEFT)
 125         , __recordingRotation(RECORDING_ROTATION_NONE)
 126         , __reloadCameraPreviewFormat(::CAMERA_PIXEL_FORMAT_I420)
 127 {
 128 }
 129
 130 _CameraCoordinator::~_CameraCoordinator()
 131 {
 132         _CameraManager::Release(__cameraDevice);
 133         SysLog(NID_MEDIA, "Camera manager released");
 134 }
 135
 136 result
 137 _CameraCoordinator::Construct(_CameraDeviceType cameraDevice)
 138 {
 139         result r = E_SUCCESS;
 140         _CameraManager* pCameraManager = null;
 141         SysLog(NID_MEDIA, "Enter. camera device:%d", cameraDevice);
 142
 143         pCameraManager = _CameraManager::AddInstance(cameraDevice);
 144         r = GetLastResult();
 145         SysTryReturn(NID_MEDIA, pCameraManager !=null && r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 146
 147         __cameraHandle = pCameraManager->GetHandle();
 148
 149         __pListenerList.reset(new (std::nothrow) LinkedListT <_ICameraCoordinatorListener*>());
 150         SysTryReturn(NID_MEDIA, __pListenerList.get() !=null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 151
 152         __cameraDevice = cameraDevice;
 153         __mode = _CAMERA_MODE_IMAGE;
 154
 155         return r;
 156 }
 157
 158 result
 159 _CameraCoordinator::AddRecorder(_RecorderDeviceType recorderDevice)
 160 {
 161         result r = E_SUCCESS;
 162         _RecorderManager* pRecorderManager = null;
 163         SysLog(NID_MEDIA, "Enter. recorder device:%d", recorderDevice);
 164
 165         pRecorderManager = _RecorderManager::AddInstance(recorderDevice);
 166         r = GetLastResult();
 167         SysTryCatch(NID_MEDIA, pRecorderManager !=null && r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 168
 169         __recorderHandle = pRecorderManager->GetHandle();               // new recorder handle
 170
 171         return r;
 172
 173 CATCH:
 174         return r;
 175 }
 176
 177 void
 178 _CameraCoordinator::RemoveRecorder(_RecorderDeviceType recorderDevice)
 179 {
 180         SysLog(NID_MEDIA, "Enter. recorder device:%d", recorderDevice);
 181         _RecorderManager::Release(recorderDevice);
 182         __recorderHandle = MM_INVALID_HANDLE;
 183         __orientationFlag = __orientationFlag & (~_ORIENTATION_FOR_RECORDING);
 184 }
 185
 186 _CameraCoordinator*
 187 _CameraCoordinator::AddInstance(_CameraDeviceType cameraDevice)
 188 {
 189         result r = E_SUCCESS;
 190         bool out = false;
 191         ClearLastResult();
 192
 193         static bool isMapConstructed = false;
 194         static _CameraCoordinatorSafeHashMapT map;
 195         _CameraCoordinator* pCoordinator = null;
 196
 197         SysTryReturn(NID_MEDIA, cameraDevice > _CAMERA_DEVICE_NONE && cameraDevice < _CAMERA_DEVICE_MAX,
 198                                 null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(camderDevice) is used. camderDevice:%d is wrong.", cameraDevice);
 199
 200         if (!isMapConstructed)
 201         {
 202                 r = map.Construct();
 203                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 204                 isMapConstructed = true;
 205                 __pMap = &map;
 206         }
 207
 208         r = map.ContainsKey(cameraDevice, out);
 209         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 210
 211         if (out)
 212         {
 213                 r = map.GetValue(cameraDevice, pCoordinator);
 214                 SysTryReturn(NID_MEDIA, r == E_SUCCESS && pCoordinator != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 215         }
 216         else
 217         {
 218                 std::unique_ptr <_CameraCoordinator> pCoord (new (std::nothrow) _CameraCoordinator());
 219                 SysTryReturn(NID_MEDIA, pCoord.get() !=null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 220
 221                 r = pCoord->Construct(cameraDevice);
 222                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 223
 224                 r = map.Add(cameraDevice, pCoord.get());
 225                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 226
 227                 pCoordinator = pCoord.release();
 228         }
 229
 230         pCoordinator->AddRefCount();
 231         return pCoordinator;
 232 }
 233
 234 _CameraCoordinator*
 235 _CameraCoordinator::AddInstance(_RecorderDeviceType recorderDevice)
 236 {
 237         _CameraCoordinator* pCoordinator = null;
 238         _CameraDeviceType cameraDevice = _CAMERA_DEVICE_NONE;
 239         ClearLastResult();
 240
 241         switch (recorderDevice)
 242         {
 243         case _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA:
 244                 cameraDevice = _CAMERA_DEVICE_PRIMARY;
 245                 break;
 246
 247         case _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA:
 248                 cameraDevice = _CAMERA_DEVICE_SECONDARY;
 249                 break;
 250
 251         default:
 252                 break;
 253         }
 254
 255         if (cameraDevice == _CAMERA_DEVICE_NONE)
 256         {
 257                 SysLogException(NID_MEDIA, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(recorderDevice) is used. recorderDevice :%d is wrong.", recorderDevice);
 258         }
 259         else
 260         {
 261                 pCoordinator = AddInstance(cameraDevice);
 262                 if (pCoordinator == null)
 263                 {
 264                         SysLogException(NID_MEDIA, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] The camera device(%d)'s coordinator is not available.", cameraDevice);
 265                 }
 266         }
 267         return pCoordinator;
 268 }
 269
 270 void
 271 _CameraCoordinator::Release(_CameraDeviceType cameraDevice)
 272 {
 273         result r = E_SUCCESS;
 274
 275         if (__pMap != null)
 276         {
 277                 _CameraCoordinator* pCoordinator = null;
 278                 r = __pMap->GetValue(cameraDevice, pCoordinator);
 279                 SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 280
 281                 if (pCoordinator->ReleaseRefCount() == 0)
 282                 {
 283                         delete pCoordinator;
 284                         r = __pMap->Remove(cameraDevice);
 285                         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 286                 }
 287         }
 288 }
 289
 290 void
 291 _CameraCoordinator::Release(_RecorderDeviceType recorderDevice)
 292 {
 293         if (__pMap != null)
 294         {
 295                 _CameraDeviceType cameraDevice = _CAMERA_DEVICE_NONE;
 296
 297                 switch (recorderDevice)
 298                 {
 299                 case _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA:
 300                         cameraDevice = _CAMERA_DEVICE_PRIMARY;
 301                         break;
 302                 case _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA:
 303                         cameraDevice = _CAMERA_DEVICE_SECONDARY;
 304                         break;
 305                 default:
 306                         break;
 307                 }
 308
 309                 Release(cameraDevice);
 310         }
 311 }
 312
 313 _CameraCoordinator*
 314 _CameraCoordinator::HasInstance(_CameraDeviceType cameraDevice)
 315 {
 316         result r = E_SUCCESS;
 317         _CameraCoordinator* pCoordinator = null;
 318         bool out = false;
 319         ClearLastResult();
 320
 321         SysTryReturn(NID_MEDIA, cameraDevice > _CAMERA_DEVICE_NONE && cameraDevice < _CAMERA_DEVICE_MAX,
 322                                 null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(camderDevice) is used. camderDevice:%d is wrong.", cameraDevice);
 323         SysTryReturn(NID_MEDIA, __pMap != null, null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] No coordinator was created.");
 324
 325         r = __pMap->ContainsKey(cameraDevice, out);
 326         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 327         SysTryCatch(NID_MEDIA, out == true, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Camera device(%d) was not created.", cameraDevice);
 328
 329         r = __pMap->GetValue(cameraDevice, pCoordinator);
 330         SysTryCatch(NID_MEDIA, r == E_SUCCESS && pCoordinator != null, , r, "[%s] Propagating.", GetErrorMessage(r));
 331
 332         return pCoordinator;
 333
 334 CATCH:
 335         return null;
 336 }
 337
 338 _CameraCoordinator*
 339 _CameraCoordinator::HasInstance(_RecorderDeviceType recorderDevice)
 340 {
 341         _CameraCoordinator* pCoordinator = null;
 342         _CameraDeviceType cameraDevice = _CAMERA_DEVICE_NONE;
 343         ClearLastResult();
 344
 345         switch (recorderDevice)
 346         {
 347         case _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA:
 348                 cameraDevice = _CAMERA_DEVICE_PRIMARY;
 349                 break;
 350
 351         case _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA:
 352                 cameraDevice = _CAMERA_DEVICE_SECONDARY;
 353                 break;
 354
 355         default:
 356                 break;
 357         }
 358
 359         if (cameraDevice == _CAMERA_DEVICE_NONE)
 360         {
 361                 SysLogException(NID_MEDIA, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(recorderDevice) is used. recorderDevice :%d is wrong.", recorderDevice);
 362         }
 363         else
 364         {
 365                 pCoordinator = HasInstance(cameraDevice);
 366                 if (pCoordinator == null)
 367                 {
 368                         SysLogException(NID_MEDIA, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] The camera device(%d)'s coordinator is not available.", cameraDevice);
 369                 }
 370         }
 371         return pCoordinator;
 372 }
 373
 374 result
 375 _CameraCoordinator::AddCameraCoordinatorListener(_ICameraCoordinatorListener& listener)
 376 {
 377         result r = E_SUCCESS;
 378         r = __pListenerList->Add(&listener);
 379         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 380         return r;
 381 }
 382
 383 result
 384 _CameraCoordinator::RemoveCameraCoordinatorListener(_ICameraCoordinatorListener& listener)
 385 {
 386         result r = E_SUCCESS;
 387         r = __pListenerList->Remove(&listener);
 388         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 389
 390         r = NotifyOtherRemoved();
 391         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 392         return r;
 393 }
 394
 395 _CameraMode
 396 _CameraCoordinator::GetMode(void) const
 397 {
 398         return __mode;
 399 }
 400
 401 _CameraHandle
 402 _CameraCoordinator::GetCameraHandle(void) const
 403 {
 404         return __cameraHandle;
 405 }
 406
 407 _RecorderHandle
 408 _CameraCoordinator::GetRecorderHandle(void) const
 409 {
 410         return __recorderHandle;
 411 }
 412
 413 result
 414 _CameraCoordinator::NotifyModeChangePrepared(_CameraMode mode)
 415 {
 416         result r = E_SUCCESS;
 417         _ICameraCoordinatorListener* pListener = null;
 418         SysLog(NID_MEDIA, "mode:%d", mode);
 419
 420         std::unique_ptr <IEnumeratorT <_ICameraCoordinatorListener*> > pEnum (__pListenerList->GetEnumeratorN());
 421         SysTryReturn(NID_MEDIA, pEnum.get() != null, GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 422
 423         while (pEnum->MoveNext() == E_SUCCESS)
 424         {
 425                 r = pEnum->GetCurrent(pListener);
 426                 SysTryReturn(NID_MEDIA, pListener != null && r == E_SUCCESS, E_SYSTEM, E_SYSTEM,
 427                                    "[E_SYSTEM] A system error has been occurred.  The listener is not proper");
 428
 429                 r = pListener->OnCameraCoordinatorModeChangePrepared(mode);
 430                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 431         }
 432         return r;
 433 }
 434
 435 result
 436 _CameraCoordinator::NotifyModeChanged(_CameraMode mode)
 437 {
 438         result r = E_SUCCESS;
 439         _ICameraCoordinatorListener* pListener = null;
 440         SysLog(NID_MEDIA, "mode:%d", mode);
 441
 442         std::unique_ptr <IEnumeratorT <_ICameraCoordinatorListener*> > pEnum (__pListenerList->GetEnumeratorN());
 443         SysTryReturn(NID_MEDIA, pEnum.get() != null, GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 444
 445         while (pEnum->MoveNext() == E_SUCCESS)
 446         {
 447                 r = pEnum->GetCurrent(pListener);
 448                 SysTryReturn(NID_MEDIA, pListener != null && r == E_SUCCESS, E_SYSTEM, E_SYSTEM,
 449                                    "[E_SYSTEM] A system error has been occurred.  The listener is not proper");
 450
 451                 r = pListener->OnCameraCoordinatorModeChanged(mode);
 452                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 453         }
 454         return r;
 455 }
 456
 457 result
 458 _CameraCoordinator::NotifyOtherRemoved(void)
 459 {
 460         result r = E_SUCCESS;
 461         _ICameraCoordinatorListener* pListener = null;
 462         SysLog(NID_MEDIA, "Enter");
 463
 464         std::unique_ptr <IEnumeratorT <_ICameraCoordinatorListener*> > pEnum (__pListenerList->GetEnumeratorN());
 465         SysTryReturn(NID_MEDIA, pEnum.get() != null, GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 466
 467         while (pEnum->MoveNext() == E_SUCCESS)
 468         {
 469                 r = pEnum->GetCurrent(pListener);
 470                 SysTryReturn(NID_MEDIA, pListener != null && r == E_SUCCESS, E_SYSTEM, E_SYSTEM,
 471                                    "[E_SYSTEM] A system error has been occurred.  The listener is not proper");
 472
 473                 r = pListener->OnCameraCoordinatorOtherRemoved();
 474                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 475         }
 476         return r;
 477 }
 478
 479 result
 480 _CameraCoordinator::StartMmPreview(void)
 481 {
 482         result r = E_SUCCESS;
 483         SysLog(NID_MEDIA, "Enter. mode:%d", __mode);
 484
 485         switch (__mode)
 486         {
 487         case _CAMERA_MODE_IMAGE:
 488                 r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 489                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 490                 break;
 491
 492         case _CAMERA_MODE_VIDEO:
 493                 r = ChangeRecorderStateTo(::RECORDER_STATE_READY);
 494                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 495                 break;
 496
 497         default:
 498                 SysLogException(NID_MEDIA, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camcorder mode :%d is wrong", __mode);
 499                 goto CATCH;
 500                 break;
 501         }
 502
 503 CATCH:
 504         return r;
 505 }
 506
 507 result
 508 _CameraCoordinator::StopMmPreview(void)
 509 {
 510         result r = E_SUCCESS;
 511         SysLog(NID_MEDIA, "Enter.");
 512
 513         if (__mode == _CAMERA_MODE_IMAGE)
 514         {
 515                 r = ChangeCameraStateTo(::CAMERA_STATE_CREATED);
 516                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 517         }
 518         else if (__mode == _CAMERA_MODE_VIDEO)
 519         {
 520                 recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 521                 recorderState = GetRecorderState();
 522
 523                 switch (recorderState)
 524                 {
 525                 case ::RECORDER_STATE_RECORDING:
 526                         r = ChangeRecorderStateTo(::RECORDER_STATE_READY);
 527                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 528
 529                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 530                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 531                         break;
 532
 533                 case ::RECORDER_STATE_READY:
 534                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 535                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 536                         break;
 537
 538                 default:
 539                         r = E_INVALID_STATE;
 540                         SysLogException(NID_MEDIA, E_INVALID_STATE, "[E_INVALID_STATE] recorderState is in an invalid state. recorderState:%d", recorderState);
 541                         break;
 542                 }
 543         }
 544         else
 545         {
 546                 r = E_INVALID_STATE;
 547                 SysLogException(NID_MEDIA, E_INVALID_STATE, "[E_INVALID_STATE] CamcorderMode is in an invalid state. mode :%d", __mode);
 548         }
 549
 550 CATCH:
 551         return r;
 552 }
 553
 554 result
 555 _CameraCoordinator::CreateVideoRecorder(void)
 556 {
 557         result r = E_SUCCESS;
 558         _RecorderDeviceType recorderDevice = _RECORDER_DEVICE_NONE;
 559         SysLog(NID_MEDIA, "enter.");
 560
 561         // Start recorder
 562         if ( __recorderHandle == MM_INVALID_HANDLE )
 563         {
 564                 recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 565                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 566                 r = AddRecorder(recorderDevice);                // recorder_create() will be called.
 567                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 568                 __mode = _CAMERA_MODE_VIDEO;
 569         }
 570         return r;
 571 CATCH:
 572         return r;
 573 }
 574
 575 result
 576 _CameraCoordinator::DestroyVideoRecorder(void)
 577 {
 578         result r = E_SUCCESS;
 579         int err = MM_SUCCESS;
 580         recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 581         _RecorderDeviceType recorderDevice = _RECORDER_DEVICE_NONE;
 582         SysLog(NID_MEDIA, "enter.");
 583
 584         if ( __recorderHandle != MM_INVALID_HANDLE )
 585         {
 586                 recorderState = GetRecorderState();
 587                 // Stop the recorder
 588                 switch (recorderState)
 589                 {
 590                 case ::RECORDER_STATE_NONE:
 591                         break;
 592
 593                 case ::RECORDER_STATE_CREATED:
 594                         //fall through
 595                 case ::RECORDER_STATE_READY:
 596                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 597                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 598                         RemoveRecorder(recorderDevice);
 599                         __mode = _CAMERA_MODE_IMAGE;
 600                         break;
 601
 602                 case ::RECORDER_STATE_RECORDING:
 603                         //fall through
 604                 case ::RECORDER_STATE_PAUSED:
 605                         err = recorder_cancel(__recorderHandle);
 606                         r = ConvertResult(err);
 607                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 608                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 609                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 610                         RemoveRecorder(recorderDevice);
 611                         __mode = _CAMERA_MODE_IMAGE;
 612                         break;
 613
 614                 default:
 615                         break;
 616                 }
 617         }
 618
 619         return r;
 620 CATCH:
 621         return r;
 622 }
 623
 624
 625 result
 626 _CameraCoordinator::ChangeFormat(_CameraMode mode, bool callback, camera_pixel_format_e reloadCameraPreviewFormat)
 627 {
 628         result r = E_SUCCESS;
 629         int err = MM_SUCCESS;
 630         _RecorderDeviceType recorderDevice = _RECORDER_DEVICE_NONE;
 631         camera_state_e cameraState = ::CAMERA_STATE_NONE;
 632         recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 633         SysLog(NID_MEDIA, "enter. mode:%d, callback:%d,         reloadCameraPreviewFormat:%d", mode, callback, reloadCameraPreviewFormat);
 634
 635         if (mode == _CAMERA_MODE_VIDEO)
 636         {
 637                 cameraState = GetCameraState();
 638
 639                 switch (cameraState)
 640                 {
 641                 case ::CAMERA_STATE_CREATED:
 642                         //fall through
 643                 case ::CAMERA_STATE_NONE:
 644                         break;
 645
 646                 case ::CAMERA_STATE_PREVIEW:
 647                         //fall through
 648                 case ::CAMERA_STATE_CAPTURED:
 649                         r = ChangeCameraStateTo(::CAMERA_STATE_CREATED);
 650                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 651                         break;
 652
 653                 case ::CAMERA_STATE_CAPTURING:
 654                         r = E_INVALID_STATE;
 655                         SysLogException(NID_MEDIA, r, "[E_INVALID_STATE] cameraState(%d) is in an invalid state. While the camera is capturing, the mode cannot be changed.", cameraState);
 656                         goto CATCH;
 657                         break;
 658
 659                 default:
 660                         break;
 661                 }
 662
 663                 __mode = _CAMERA_MODE_VIDEO;
 664                 __reloadCameraPreviewFormat = reloadCameraPreviewFormat;
 665                 if (callback)
 666                 {
 667                         r = NotifyModeChangePrepared(mode);
 668                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 669                 }
 670
 671                 switch (cameraState)
 672                 {
 673                 case ::CAMERA_STATE_NONE:
 674                         //fall through
 675                 case ::CAMERA_STATE_CREATED:
 676                         break;
 677
 678                 case ::CAMERA_STATE_PREVIEW:
 679                         r = ChangeRecorderStateTo(::RECORDER_STATE_READY);
 680                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 681                         break;
 682
 683                 case ::CAMERA_STATE_CAPTURED:
 684                 default:
 685                         break;
 686                 }
 687         }
 688         else if ( mode == _CAMERA_MODE_IMAGE )
 689         {
 690                 recorderState = GetRecorderState();
 691
 692                 switch (recorderState)
 693                 {
 694                 case ::RECORDER_STATE_NONE:
 695                         break;
 696                 case ::RECORDER_STATE_CREATED:
 697                         __mode = _CAMERA_MODE_IMAGE;
 698                         __reloadCameraPreviewFormat = reloadCameraPreviewFormat;
 699                         if (callback)
 700                         {
 701                                 r = NotifyModeChangePrepared(mode);
 702                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 703                         }
 704                         break;
 705
 706                 case ::RECORDER_STATE_READY:
 707                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 708                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 709
 710                         __mode = _CAMERA_MODE_IMAGE;
 711                         __reloadCameraPreviewFormat = reloadCameraPreviewFormat;
 712                         if (callback)
 713                         {
 714                                 r = NotifyModeChangePrepared(mode);
 715                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 716                         }
 717                         r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 718                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 719                         break;
 720
 721                 case ::RECORDER_STATE_RECORDING:
 722                         //fall through
 723                 case ::RECORDER_STATE_PAUSED:
 724                         err = recorder_cancel(__recorderHandle);                // TODO
 725                         r = ConvertResult(err);
 726                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 727
 728                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 729                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 730                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 731                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 732
 733                         __mode = _CAMERA_MODE_IMAGE;
 734                         __reloadCameraPreviewFormat = reloadCameraPreviewFormat;
 735                         if (callback)
 736                         {
 737                                 r = NotifyModeChangePrepared(mode);
 738                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 739                         }
 740                         r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 741                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 742                         break;
 743
 744                 default:
 745                         break;
 746                 }
 747         }
 748
 749         if (callback)
 750         {
 751                 // Notify that the mode is changed to callback camera and video recorder's configurations.
 752                 r = NotifyModeChanged(mode);
 753                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 754         }
 755         return r;
 756 CATCH:
 757         return r;
 758 }
 759
 760 result
 761 _CameraCoordinator::ChangeMode(_CameraMode mode, bool callback)
 762 {
 763         result r = E_SUCCESS;
 764         camera_state_e cameraState = ::CAMERA_STATE_NONE;
 765         recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 766         _RecorderDeviceType recorderDevice = _RECORDER_DEVICE_NONE;
 767         int err = MM_SUCCESS;
 768
 769         SysLog(NID_MEDIA, "Mode should be changed. mode:%d", mode);
 770         if (mode == _CAMERA_MODE_VIDEO)
 771         {
 772                 cameraState = GetCameraState();
 773
 774                 switch (cameraState)
 775                 {
 776                 case ::CAMERA_STATE_CREATED:
 777                         //fall through
 778                 case ::CAMERA_STATE_NONE:
 779                         break;
 780
 781                 case ::CAMERA_STATE_PREVIEW:
 782                         //fall through
 783                 case ::CAMERA_STATE_CAPTURED:
 784                         r = ChangeCameraStateTo(::CAMERA_STATE_CREATED);
 785                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 786                         break;
 787
 788                 case ::CAMERA_STATE_CAPTURING:
 789                         r = E_INVALID_STATE;
 790                         SysLogException(NID_MEDIA, r, "[E_INVALID_STATE] cameraState(%d) is in an invalid state. While the camera is capturing, the mode cannot be changed.", cameraState);
 791                         goto CATCH;
 792                         break;
 793
 794                 default:
 795                         break;
 796                 }
 797
 798                 // Start recorder
 799                 if ( __recorderHandle == MM_INVALID_HANDLE )
 800                 {
 801                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 802                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 803                         r = AddRecorder(recorderDevice);                // recorder_create() will be called.
 804                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 805                         __mode = _CAMERA_MODE_VIDEO;
 806                 }
 807
 808                 if (callback)
 809                 {
 810                         r = NotifyModeChangePrepared(mode);
 811                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 812                 }
 813
 814                 switch (cameraState)
 815                 {
 816                 case ::CAMERA_STATE_NONE:
 817                         //fall through
 818                 case ::CAMERA_STATE_CREATED:
 819                         break;
 820
 821                 case ::CAMERA_STATE_PREVIEW:
 822                         r = ChangeRecorderStateTo(::RECORDER_STATE_READY);
 823                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 824                         break;
 825
 826                 case ::CAMERA_STATE_CAPTURED:
 827                 default:
 828                         break;
 829                 }
 830         }
 831         else if ( mode == _CAMERA_MODE_IMAGE )
 832         {
 833                 recorderState = GetRecorderState();
 834
 835                 // Stop the recorder
 836                 switch (recorderState)
 837                 {
 838                 case ::RECORDER_STATE_NONE:
 839                         break;
 840
 841                 case ::RECORDER_STATE_CREATED:
 842                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 843                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 844                         RemoveRecorder(recorderDevice);         // the mode will be changed to IMAGE.
 845                         __mode = _CAMERA_MODE_IMAGE;
 846                         break;
 847
 848                 case ::RECORDER_STATE_READY:
 849                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 850                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 851
 852                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 853                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 854                         RemoveRecorder(recorderDevice);
 855                         __mode = _CAMERA_MODE_IMAGE;
 856                         if (callback)
 857                         {
 858                                 r = NotifyModeChangePrepared(mode);
 859                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 860                         }
 861                         r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 862                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 863                         break;
 864
 865                 case ::RECORDER_STATE_RECORDING:
 866                         //fall through
 867                 case ::RECORDER_STATE_PAUSED:
 868                         err = recorder_cancel(__recorderHandle);                // TODO
 869                         r = ConvertResult(err);
 870                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 871
 872                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 873                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 874                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 875                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 876
 877                         RemoveRecorder(recorderDevice);
 878                         __mode = _CAMERA_MODE_IMAGE;
 879                         if (callback)
 880                         {
 881                                 r = NotifyModeChangePrepared(mode);
 882                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 883                         }
 884                         r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 885                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 886                         break;
 887
 888                 default:
 889                         break;
 890                 }
 891         }
 892
 893         if (callback)
 894         {
 895                 // Notify that the mode is changed to callback camera and video recorder's configurations.
 896                 r = NotifyModeChanged(mode);
 897                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 898         }
 899
 900         return r;
 901
 902 CATCH:
 903         return r;
 904 }
 905
 906 bool
 907 _CameraCoordinator::IsCalmChangeMode(_CameraMode mode)
 908 {
 909         camera_state_e cameraState = ::CAMERA_STATE_NONE;
 910         recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 911         bool calmChange = false;
 912
 913         if (mode == _CAMERA_MODE_VIDEO)
 914         {
 915                 cameraState = GetCameraState();
 916
 917                 switch (cameraState)
 918                 {
 919                 case ::CAMERA_STATE_CREATED:
 920                         //fall through
 921                 case ::CAMERA_STATE_NONE:
 922                         calmChange = true;
 923                         break;
 924
 925                 case ::CAMERA_STATE_PREVIEW:
 926                         //fall through
 927                 case ::CAMERA_STATE_CAPTURED:
 928                         //fall through
 929                 case ::CAMERA_STATE_CAPTURING:
 930                         calmChange = false;
 931                         break;
 932
 933                 default:
 934                         break;
 935                 }
 936         }
 937         else if ( mode == _CAMERA_MODE_IMAGE )
 938         {
 939                 recorderState = GetRecorderState();
 940
 941                 // Stop the recorder
 942                 switch (recorderState)
 943                 {
 944                 case ::RECORDER_STATE_NONE:
 945                         //fall through
 946                 case ::RECORDER_STATE_CREATED:
 947                         calmChange = true;
 948                         break;
 949
 950                 case ::RECORDER_STATE_READY:
 951                         //fall through
 952                 case ::RECORDER_STATE_RECORDING:
 953                         //fall through
 954                 case ::RECORDER_STATE_PAUSED:
 955                         calmChange = false;
 956                         break;
 957
 958                 default:
 959                         break;
 960                 }
 961         }
 962
 963         SysLog(NID_MEDIA, "mode:%d, calm:%d", mode, calmChange);
 964         return calmChange;
 965 }
 966
 967
 968 _CameraDeviceType
 969 _CameraCoordinator::GetCameraDevice(void) const
 970 {
 971         return __cameraDevice;
 972 }
 973
 974 camera_state_e
 975 _CameraCoordinator::GetCameraState(void) const
 976 {
 977         result r = E_SUCCESS;
 978         int err = MM_SUCCESS;
 979         camera_state_e state = ::CAMERA_STATE_NONE;
 980
 981         err = camera_get_state(__cameraHandle, &state);
 982         r = ConvertResult(err);
 983         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 984
 985         return state;
 986
 987 CATCH:
 988         return ::CAMERA_STATE_NONE;
 989 }
 990
 991 recorder_state_e
 992 _CameraCoordinator::GetRecorderState(void) const
 993 {
 994         result r = E_SUCCESS;
 995         int err = MM_SUCCESS;
 996         recorder_state_e state = ::RECORDER_STATE_NONE;
 997
 998         err = recorder_get_state(__recorderHandle, &state);
 999         r = ConvertResult(err);
1000         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1001
1002         return state;
1003
1004 CATCH:
1005         return ::RECORDER_STATE_NONE;
1006 }
1007
1008 result
1009 _CameraCoordinator::ConvertResult(int err) const
1010 {
1011         result r = E_SYSTEM;
1012         if (err != CAMERA_ERROR_NONE)
1013         {
1014                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
1015         }
1016
1017         // Global error
1018         if (err == CAMERA_ERROR_NONE || err == RECORDER_ERROR_NONE)
1019         {
1020                 r = E_SUCCESS;
1021         }
1022         else if (err == CAMERA_ERROR_INVALID_PARAMETER || err == RECORDER_ERROR_INVALID_PARAMETER)
1023         {
1024                 r = E_INVALID_ARG;
1025         }
1026         else if (err == CAMERA_ERROR_INVALID_STATE || err == RECORDER_ERROR_INVALID_STATE)
1027         {
1028                 r = E_INVALID_STATE;
1029         }
1030         else if (err == CAMERA_ERROR_OUT_OF_MEMORY || err == RECORDER_ERROR_OUT_OF_MEMORY)
1031         {
1032                 r = E_OUT_OF_MEMORY;
1033         }
1034         else if (err == CAMERA_ERROR_DEVICE || err == RECORDER_ERROR_DEVICE)
1035         {
1036                 r = E_DEVICE_FAILED;
1037         }
1038         else if (err == CAMERA_ERROR_INVALID_OPERATION
1039                         || err == CAMERA_ERROR_SECURITY_RESTRICTED
1040                         || err == RECORDER_ERROR_INVALID_OPERATION
1041                         || err == RECORDER_ERROR_SECURITY_RESTRICTED)
1042         {
1043                 r = E_SYSTEM;
1044         }
1045         else if (err == CAMERA_ERROR_DEVICE_BUSY
1046                         || err == CAMERA_ERROR_SOUND_POLICY
1047                         || err == RECORDER_ERROR_SOUND_POLICY)
1048         {
1049                 r = E_DEVICE_BUSY;
1050         }
1051         else if (err == CAMERA_ERROR_DEVICE_NOT_FOUND)
1052         {
1053                 r = E_DEVICE_UNAVAILABLE;
1054         }
1055         else
1056         {
1057                 r = E_UNKNOWN;
1058         }
1059
1060         return r;
1061 }
1062
1063
1064 result
1065 _CameraCoordinator::ChangeCameraStateTo(camera_state_e destState)
1066 {
1067         result r = E_SUCCESS;
1068         int tableTotalCount = 0;
1069         int i = 0;
1070         int err = MM_SUCCESS;
1071         camera_state_e preState = ::CAMERA_STATE_NONE;
1072         camera_state_e postState = ::CAMERA_STATE_NONE;
1073
1074         preState = GetCameraState();
1075         tableTotalCount = sizeof(_CAMERA_STATE_TRANSIT) / sizeof(_CAMERA_STATE_TRANSIT[0]);
1076         SysLog(NID_MEDIA, " PreState:%d, destState:%d, tableTotalCount:%d", preState, destState, tableTotalCount);
1077
1078         for (i = 0; i < tableTotalCount; i++)
1079         {
1080                 if (preState == _CAMERA_STATE_TRANSIT[i].prevState && destState == _CAMERA_STATE_TRANSIT[i].postState)
1081                 {
1082                         if (_CAMERA_STATE_TRANSIT[i].pFunc != null)
1083                         {
1084                                 SysLog(NID_MEDIA,
1085                                                         "Exist the matching state field. loop i:%d, current state:%d, destState:%d", i,
1086                                                         preState, destState);
1087                                 err = _CAMERA_STATE_TRANSIT[i].pFunc(__cameraHandle);
1088                                 r = ConvertResult(err);
1089                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1090
1091                                 // Check whether the retuned states are destinationed states.
1092                                 postState = GetCameraState();
1093                                 SysTryCatch(NID_MEDIA, destState == postState, r = E_INVALID_STATE, E_INVALID_STATE,
1094                                                    "[E_INVALID_STATE] camera_state_e of C-API is in an invalid state. result preState:%d, is different from the desired state:%d", postState,
1095                                                    destState);
1096                                 SysLog(NID_MEDIA, "[E_SUCCESS] Found. result postState:%d, param destState:%d", postState,
1097                                                         destState);
1098                         }
1099                         break;
1100                 }
1101
1102         }
1103         SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
1104         return r;
1105
1106 CATCH:
1107         SysLog(NID_MEDIA, "[%s] Real preState:%d, param destState:%d", GetErrorMessage(r), preState, destState);
1108         return r;
1109 }
1110
1111 result
1112 _CameraCoordinator::ChangeRecorderStateTo(recorder_state_e destState)
1113 {
1114         result r = E_SUCCESS;
1115         int tableTotalCount = 0;
1116         int i = 0;
1117         int err = MM_SUCCESS;
1118         recorder_state_e preState = ::RECORDER_STATE_NONE;
1119         recorder_state_e postState = ::RECORDER_STATE_NONE;
1120
1121         preState = GetRecorderState();
1122         tableTotalCount = sizeof(_RECORDER_STATE_TRANSIT) / sizeof(_RECORDER_STATE_TRANSIT[0]);
1123         SysLog(NID_MEDIA, " PreState:%d, destState:%d, tableTotalCount:%d", preState, destState, tableTotalCount);
1124
1125         for (i = 0; i < tableTotalCount; i++)
1126         {
1127                 if (preState == _RECORDER_STATE_TRANSIT[i].prevState && destState == _RECORDER_STATE_TRANSIT[i].postState)
1128                 {
1129                         if (_RECORDER_STATE_TRANSIT[i].pFunc != null)
1130                         {
1131                                 SysLog(NID_MEDIA,
1132                                                         "Exist the matching state field. loop i:%d, current state:%d, destState:%d", i,
1133                                                         preState, destState);
1134                                 err = _RECORDER_STATE_TRANSIT[i].pFunc(__recorderHandle);
1135                                 r = ConvertResult(err);
1136                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1137
1138                                 // Check whether the retuned states are destinationed states.
1139                                 postState = GetRecorderState();
1140                                 SysTryCatch(NID_MEDIA, destState == postState, r = E_INVALID_STATE, E_INVALID_STATE,
1141                                                    "[E_INVALID_STATE] recorder_state_e of C-API is in an invalid state. result preState:%d, is different from the desired state:%d", postState,
1142                                                    destState);
1143                                 SysLog(NID_MEDIA, "[E_SUCCESS] Found. result preState:%d, param destState:%d", postState,
1144                                                         destState);
1145                         }
1146                         break;
1147                 }
1148
1149         }
1150         SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
1151         return r;
1152
1153 CATCH:
1154         SysLog(NID_MEDIA, "[%s] Real preState:%d, param destState:%d", GetErrorMessage(r), preState, destState);
1155         return r;
1156 }
1157
1158 result
1159 _CameraCoordinator::SetCameraSourceFormat(camera_pixel_format_e pixelFormat)
1160 {
1161         result r = E_SUCCESS;
1162         int err = MM_SUCCESS;
1163         SysLog(NID_MEDIA, "Camera_pixel_format_e is :%d", pixelFormat);
1164
1165         err = camera_set_preview_format(__cameraHandle, pixelFormat);
1166         r = ConvertResult(err);
1167         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating, pixelFormat:%d", GetErrorMessage(r), pixelFormat);
1168
1169         return r;
1170
1171 CATCH:
1172         return r;
1173 }
1174
1175 camera_pixel_format_e
1176 _CameraCoordinator::GetCameraSourceFormat(void) const
1177 {
1178         result r = E_SUCCESS;
1179         int err = MM_SUCCESS;
1180         camera_pixel_format_e pixelFormat = CAMERA_PIXEL_FORMAT_INVALID;
1181
1182         err = camera_get_preview_format(__cameraHandle, &pixelFormat);
1183         r = ConvertResult(err);
1184         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
1185
1186         return pixelFormat;
1187
1188 CATCH:
1189         return pixelFormat;
1190 }
1191
1192 result
1193 _CameraCoordinator::StartCapture(camera_capturing_cb capturingCb , camera_capture_completed_cb completedCb , void *pUserData)
1194 {
1195         result r = E_SUCCESS;
1196         int err = MM_SUCCESS;
1197
1198         if (__orientationFlag & _ORIENTATION_FOR_CAMERA)
1199         {
1200                 r = SetCameraOrientationAttr(__cameraOrientation);
1201                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1202         }
1203         else if (__orientationFlag & _ORIENTATION_FOR_RECORDING)        // If recorder setting is remained.
1204         {
1205                 r = SetCameraOrientationAttr(CAMERA_EXIF_ORIENTATION_TOP_LEFT); // To set the init value
1206                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1207         }
1208
1209         __mode = _CAMERA_MODE_IMAGE;
1210         err = camera_start_capture(__cameraHandle, capturingCb, completedCb, pUserData);
1211         r = ConvertResult(err);
1212         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Camera capture failed.", GetErrorMessage(r));
1213
1214         return r;
1215 }
1216
1217 result
1218 _CameraCoordinator::StartRecord(void)
1219 {
1220         result r = E_SUCCESS;
1221         int err = MM_SUCCESS;
1222
1223         if (__orientationFlag & _ORIENTATION_FOR_RECORDING)
1224         {
1225                 r = SetRecordingOrientationAttr(__recordingRotation);
1226                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1227         }
1228         else if (__orientationFlag & _ORIENTATION_FOR_CAMERA)   // If recorder setting is remained.
1229         {
1230                 r = SetRecordingOrientationAttr(RECORDING_ROTATION_NONE);       // To set the init value
1231                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1232         }
1233
1234         __mode = _CAMERA_MODE_VIDEO;
1235         err = recorder_start(__recorderHandle);
1236         r = ConvertResult(err);
1237         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Recorder record failed.", GetErrorMessage(r));
1238
1239         return r;
1240 }
1241
1242 void
1243 _CameraCoordinator::SetRecordingOrientation(RecordingRotation rotation)
1244 {
1245         __orientationFlag = __orientationFlag | _ORIENTATION_FOR_RECORDING;
1246         __recordingRotation = rotation;
1247 }
1248
1249 void
1250 _CameraCoordinator::SetCameraOrientation(CameraExifOrientation orientation)
1251 {
1252         __orientationFlag = __orientationFlag | _ORIENTATION_FOR_CAMERA;
1253         __cameraOrientation = orientation;
1254 }
1255
1256 result
1257 _CameraCoordinator::SetRecordingOrientationAttr(RecordingRotation rotation)
1258 {
1259         result r = E_SUCCESS;
1260         int err = MM_SUCCESS;
1261 #if _VIDEO_RECORDER_ROTATION_
1262         recorder_rotation_e mmAttr = ::RECORDER_ROTATION_NONE;
1263         r = _RecorderUtil::GetMmRotation(rotation, mmAttr);
1264         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), rotation);
1265
1266         err = recorder_attr_set_recording_orientation(__recorderHandle, mmAttr);
1267         r = ConvertResult(err);
1268         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Camcorder set attribute failed. rotation:%d", GetErrorMessage(r), rotation);
1269 #else
1270         CameraRotation cameraRotation = CAMERA_ROTATION_NONE;
1271         r = _RecorderUtil::GetCameraRotation(rotation, cameraRotation);
1272         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), rotation);
1273
1274         camera_attr_tag_orientation_e mmOrientationAttr = CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT;
1275         r = _CameraUtil::GetMmExifOrientation(cameraRotation, mmOrientationAttr);
1276         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), rotation);
1277
1278         err = camera_attr_set_tag_orientation(__cameraHandle, mmOrientationAttr);
1279         r = ConvertResult(err);
1280         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Camcorder set attribute failed. Mm orientation:%d", GetErrorMessage(r), mmOrientationAttr);
1281 #endif
1282
1283         return r;
1284 }
1285
1286 result
1287 _CameraCoordinator::SetCameraOrientationAttr(CameraExifOrientation orientation)
1288 {
1289         result r = E_SUCCESS;
1290         int err = MM_SUCCESS;
1291         camera_attr_tag_orientation_e attr = ::CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT;
1292
1293         r = _CameraUtil::GetMmExifOrientation(orientation, attr);
1294         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. orientation:%d", GetErrorMessage(r), orientation);
1295
1296         err = camera_attr_set_tag_orientation(__cameraHandle, attr);
1297         r = ConvertResult(err);
1298         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. orientation:%d", GetErrorMessage(r), orientation);
1299
1300         return r;
1301 }
1302
1303 camera_pixel_format_e
1304 _CameraCoordinator::GetReloadPreviewFormat(void) const
1305 {
1306         SysLog(NID_MEDIA, "reloadCameraPreviewFormat is :%d", __reloadCameraPreviewFormat);
1307         return __reloadCameraPreviewFormat;
1308 }
1309 }}