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