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         return r;
 380 }
 381
 382 result
 383 _CameraCoordinator::RemoveCameraCoordinatorListener(_ICameraCoordinatorListener& listener)
 384 {
 385         result r = E_SUCCESS;
 386         r = __pListenerList->Remove(&listener);
 387         return r;
 388 }
 389
 390 _CameraMode
 391 _CameraCoordinator::GetMode(void) const
 392 {
 393         return __mode;
 394 }
 395
 396 _CameraHandle
 397 _CameraCoordinator::GetCameraHandle(void) const
 398 {
 399         return __cameraHandle;
 400 }
 401
 402 _RecorderHandle
 403 _CameraCoordinator::GetRecorderHandle(void) const
 404 {
 405         return __recorderHandle;
 406 }
 407
 408 result
 409 _CameraCoordinator::NotifyModeChangePrepared(_CameraMode mode)
 410 {
 411         result r = E_SUCCESS;
 412         _ICameraCoordinatorListener* pListener = null;
 413         SysLog(NID_MEDIA, "mode:%d", mode);
 414
 415         std::unique_ptr <IEnumeratorT <_ICameraCoordinatorListener*> > pEnum (__pListenerList->GetEnumeratorN());
 416         SysTryReturn(NID_MEDIA, pEnum.get() != null, GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 417
 418         while (pEnum->MoveNext() == E_SUCCESS)
 419         {
 420                 r = pEnum->GetCurrent(pListener);
 421                 SysTryReturn(NID_MEDIA, pListener != null && r == E_SUCCESS, E_SYSTEM, E_SYSTEM,
 422                                    "[E_SYSTEM] A system error has been occurred.  The listener is not proper");
 423
 424                 r = pListener->OnCameraCoordinatorModeChangePrepared(mode);
 425                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 426         }
 427         return r;
 428 }
 429
 430 result
 431 _CameraCoordinator::NotifyModeChanged(_CameraMode mode)
 432 {
 433         result r = E_SUCCESS;
 434         _ICameraCoordinatorListener* pListener = null;
 435         SysLog(NID_MEDIA, "mode:%d", mode);
 436
 437         std::unique_ptr <IEnumeratorT <_ICameraCoordinatorListener*> > pEnum (__pListenerList->GetEnumeratorN());
 438         SysTryReturn(NID_MEDIA, pEnum.get() != null, GetLastResult(), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 439
 440         while (pEnum->MoveNext() == E_SUCCESS)
 441         {
 442                 r = pEnum->GetCurrent(pListener);
 443                 SysTryReturn(NID_MEDIA, pListener != null && r == E_SUCCESS, E_SYSTEM, E_SYSTEM,
 444                                    "[E_SYSTEM] A system error has been occurred.  The listener is not proper");
 445
 446                 r = pListener->OnCameraCoordinatorModeChanged(mode);
 447                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 448         }
 449         return r;
 450 }
 451
 452 result
 453 _CameraCoordinator::StartMmPreview(void)
 454 {
 455         result r = E_SUCCESS;
 456         SysLog(NID_MEDIA, "Enter. mode:%d", __mode);
 457
 458         switch (__mode)
 459         {
 460         case _CAMERA_MODE_IMAGE:
 461                 r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 462                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 463                 break;
 464
 465         case _CAMERA_MODE_VIDEO:
 466                 r = ChangeRecorderStateTo(::RECORDER_STATE_READY);
 467                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 468                 break;
 469
 470         default:
 471                 SysLogException(NID_MEDIA, E_INVALID_STATE, "[E_INVALID_STATE] Camera is in an invalid state. Camcorder mode :%d is wrong", __mode);
 472                 goto CATCH;
 473                 break;
 474         }
 475
 476 CATCH:
 477         return r;
 478 }
 479
 480 result
 481 _CameraCoordinator::StopMmPreview(void)
 482 {
 483         result r = E_SUCCESS;
 484         SysLog(NID_MEDIA, "Enter.");
 485
 486         if (__mode == _CAMERA_MODE_IMAGE)
 487         {
 488                 r = ChangeCameraStateTo(::CAMERA_STATE_CREATED);
 489                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 490         }
 491         else if (__mode == _CAMERA_MODE_VIDEO)
 492         {
 493                 recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 494                 recorderState = GetRecorderState();
 495
 496                 switch (recorderState)
 497                 {
 498                 case ::RECORDER_STATE_RECORDING:
 499                         r = ChangeRecorderStateTo(::RECORDER_STATE_READY);
 500                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 501
 502                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 503                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 504                         break;
 505
 506                 case ::RECORDER_STATE_READY:
 507                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 508                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 509                         break;
 510
 511                 default:
 512                         r = E_INVALID_STATE;
 513                         SysLogException(NID_MEDIA, E_INVALID_STATE, "[E_INVALID_STATE] recorderState is in an invalid state. recorderState:%d", recorderState);
 514                         break;
 515                 }
 516         }
 517         else
 518         {
 519                 r = E_INVALID_STATE;
 520                 SysLogException(NID_MEDIA, E_INVALID_STATE, "[E_INVALID_STATE] CamcorderMode is in an invalid state. mode :%d", __mode);
 521         }
 522
 523 CATCH:
 524         return r;
 525 }
 526
 527 result
 528 _CameraCoordinator::CreateVideoRecorder(void)
 529 {
 530         result r = E_SUCCESS;
 531         _RecorderDeviceType recorderDevice = _RECORDER_DEVICE_NONE;
 532         SysLog(NID_MEDIA, "enter.");
 533
 534         // Start recorder
 535         if ( __recorderHandle == MM_INVALID_HANDLE )
 536         {
 537                 recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 538                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 539                 r = AddRecorder(recorderDevice);                // recorder_create() will be called.
 540                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 541                 __mode = _CAMERA_MODE_VIDEO;
 542         }
 543         return r;
 544 CATCH:
 545         return r;
 546 }
 547
 548 result
 549 _CameraCoordinator::DestroyVideoRecorder(void)
 550 {
 551         result r = E_SUCCESS;
 552         int err = MM_SUCCESS;
 553         recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 554         _RecorderDeviceType recorderDevice = _RECORDER_DEVICE_NONE;
 555         SysLog(NID_MEDIA, "enter.");
 556
 557         if ( __recorderHandle != MM_INVALID_HANDLE )
 558         {
 559                 recorderState = GetRecorderState();
 560                 // Stop the recorder
 561                 switch (recorderState)
 562                 {
 563                 case ::RECORDER_STATE_NONE:
 564                         break;
 565
 566                 case ::RECORDER_STATE_CREATED:
 567                         //fall through
 568                 case ::RECORDER_STATE_READY:
 569                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 570                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 571                         RemoveRecorder(recorderDevice);
 572                         __mode = _CAMERA_MODE_IMAGE;
 573                         break;
 574
 575                 case ::RECORDER_STATE_RECORDING:
 576                         //fall through
 577                 case ::RECORDER_STATE_PAUSED:
 578                         err = recorder_cancel(__recorderHandle);
 579                         r = ConvertResult(err);
 580                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 581                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 582                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 583                         RemoveRecorder(recorderDevice);
 584                         __mode = _CAMERA_MODE_IMAGE;
 585                         break;
 586
 587                 default:
 588                         break;
 589                 }
 590         }
 591
 592         return r;
 593 CATCH:
 594         return r;
 595 }
 596
 597
 598 result
 599 _CameraCoordinator::ChangeFormat(_CameraMode mode, bool callback, camera_pixel_format_e reloadCameraPreviewFormat)
 600 {
 601         result r = E_SUCCESS;
 602         int err = MM_SUCCESS;
 603         _RecorderDeviceType recorderDevice = _RECORDER_DEVICE_NONE;
 604         camera_state_e cameraState = ::CAMERA_STATE_NONE;
 605         recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 606         SysLog(NID_MEDIA, "enter. mode:%d, callback:%d,         reloadCameraPreviewFormat:%d", mode, callback, reloadCameraPreviewFormat);
 607
 608         if (mode == _CAMERA_MODE_VIDEO)
 609         {
 610                 cameraState = GetCameraState();
 611
 612                 switch (cameraState)
 613                 {
 614                 case ::CAMERA_STATE_CREATED:
 615                         //fall through
 616                 case ::CAMERA_STATE_NONE:
 617                         break;
 618
 619                 case ::CAMERA_STATE_PREVIEW:
 620                         //fall through
 621                 case ::CAMERA_STATE_CAPTURED:
 622                         r = ChangeCameraStateTo(::CAMERA_STATE_CREATED);
 623                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 624                         break;
 625
 626                 case ::CAMERA_STATE_CAPTURING:
 627                         r = E_INVALID_STATE;
 628                         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);
 629                         goto CATCH;
 630                         break;
 631
 632                 default:
 633                         break;
 634                 }
 635
 636                 __mode = _CAMERA_MODE_VIDEO;
 637                 __reloadCameraPreviewFormat = reloadCameraPreviewFormat;
 638                 if (callback)
 639                 {
 640                         r = NotifyModeChangePrepared(mode);
 641                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 642                 }
 643
 644                 switch (cameraState)
 645                 {
 646                 case ::CAMERA_STATE_NONE:
 647                         //fall through
 648                 case ::CAMERA_STATE_CREATED:
 649                         break;
 650
 651                 case ::CAMERA_STATE_PREVIEW:
 652                         r = ChangeRecorderStateTo(::RECORDER_STATE_READY);
 653                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 654                         break;
 655
 656                 case ::CAMERA_STATE_CAPTURED:
 657                 default:
 658                         break;
 659                 }
 660         }
 661         else if ( mode == _CAMERA_MODE_IMAGE )
 662         {
 663                 recorderState = GetRecorderState();
 664
 665                 switch (recorderState)
 666                 {
 667                 case ::RECORDER_STATE_NONE:
 668                         break;
 669                 case ::RECORDER_STATE_CREATED:
 670                         __mode = _CAMERA_MODE_IMAGE;
 671                         __reloadCameraPreviewFormat = reloadCameraPreviewFormat;
 672                         if (callback)
 673                         {
 674                                 r = NotifyModeChangePrepared(mode);
 675                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 676                         }
 677                         break;
 678
 679                 case ::RECORDER_STATE_READY:
 680                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 681                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 682
 683                         __mode = _CAMERA_MODE_IMAGE;
 684                         __reloadCameraPreviewFormat = reloadCameraPreviewFormat;
 685                         if (callback)
 686                         {
 687                                 r = NotifyModeChangePrepared(mode);
 688                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 689                         }
 690                         r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 691                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 692                         break;
 693
 694                 case ::RECORDER_STATE_RECORDING:
 695                         //fall through
 696                 case ::RECORDER_STATE_PAUSED:
 697                         err = recorder_cancel(__recorderHandle);                // TODO
 698                         r = ConvertResult(err);
 699                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 700
 701                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 702                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 703                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 704                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 705
 706                         __mode = _CAMERA_MODE_IMAGE;
 707                         __reloadCameraPreviewFormat = reloadCameraPreviewFormat;
 708                         if (callback)
 709                         {
 710                                 r = NotifyModeChangePrepared(mode);
 711                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 712                         }
 713                         r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 714                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 715                         break;
 716
 717                 default:
 718                         break;
 719                 }
 720         }
 721
 722         if (callback)
 723         {
 724                 // Notify that the mode is changed to callback camera and video recorder's configurations.
 725                 r = NotifyModeChanged(mode);
 726                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 727         }
 728         return r;
 729 CATCH:
 730         return r;
 731 }
 732
 733 result
 734 _CameraCoordinator::ChangeMode(_CameraMode mode, bool callback)
 735 {
 736         result r = E_SUCCESS;
 737         camera_state_e cameraState = ::CAMERA_STATE_NONE;
 738         recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 739         _RecorderDeviceType recorderDevice = _RECORDER_DEVICE_NONE;
 740         int err = MM_SUCCESS;
 741
 742         SysLog(NID_MEDIA, "Mode should be changed. mode:%d", mode);
 743         if (mode == _CAMERA_MODE_VIDEO)
 744         {
 745                 cameraState = GetCameraState();
 746
 747                 switch (cameraState)
 748                 {
 749                 case ::CAMERA_STATE_CREATED:
 750                         //fall through
 751                 case ::CAMERA_STATE_NONE:
 752                         break;
 753
 754                 case ::CAMERA_STATE_PREVIEW:
 755                         //fall through
 756                 case ::CAMERA_STATE_CAPTURED:
 757                         r = ChangeCameraStateTo(::CAMERA_STATE_CREATED);
 758                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 759                         break;
 760
 761                 case ::CAMERA_STATE_CAPTURING:
 762                         r = E_INVALID_STATE;
 763                         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);
 764                         goto CATCH;
 765                         break;
 766
 767                 default:
 768                         break;
 769                 }
 770
 771                 // Start recorder
 772                 if ( __recorderHandle == MM_INVALID_HANDLE )
 773                 {
 774                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 775                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 776                         r = AddRecorder(recorderDevice);                // recorder_create() will be called.
 777                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 778                         __mode = _CAMERA_MODE_VIDEO;
 779                 }
 780
 781                 if (callback)
 782                 {
 783                         r = NotifyModeChangePrepared(mode);
 784                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 785                 }
 786
 787                 switch (cameraState)
 788                 {
 789                 case ::CAMERA_STATE_NONE:
 790                         //fall through
 791                 case ::CAMERA_STATE_CREATED:
 792                         break;
 793
 794                 case ::CAMERA_STATE_PREVIEW:
 795                         r = ChangeRecorderStateTo(::RECORDER_STATE_READY);
 796                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 797                         break;
 798
 799                 case ::CAMERA_STATE_CAPTURED:
 800                 default:
 801                         break;
 802                 }
 803         }
 804         else if ( mode == _CAMERA_MODE_IMAGE )
 805         {
 806                 recorderState = GetRecorderState();
 807
 808                 // Stop the recorder
 809                 switch (recorderState)
 810                 {
 811                 case ::RECORDER_STATE_NONE:
 812                         break;
 813
 814                 case ::RECORDER_STATE_CREATED:
 815                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 816                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 817                         RemoveRecorder(recorderDevice);         // the mode will be changed to IMAGE.
 818                         __mode = _CAMERA_MODE_IMAGE;
 819                         break;
 820
 821                 case ::RECORDER_STATE_READY:
 822                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 823                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 824
 825                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 826                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 827                         RemoveRecorder(recorderDevice);
 828                         __mode = _CAMERA_MODE_IMAGE;
 829                         if (callback)
 830                         {
 831                                 r = NotifyModeChangePrepared(mode);
 832                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 833                         }
 834                         r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 835                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 836                         break;
 837
 838                 case ::RECORDER_STATE_RECORDING:
 839                         //fall through
 840                 case ::RECORDER_STATE_PAUSED:
 841                         err = recorder_cancel(__recorderHandle);                // TODO
 842                         r = ConvertResult(err);
 843                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 844
 845                         r = ChangeRecorderStateTo(::RECORDER_STATE_CREATED);
 846                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 847                         recorderDevice = __cameraDevice == _CAMERA_DEVICE_PRIMARY ?
 848                                 _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA;
 849
 850                         RemoveRecorder(recorderDevice);
 851                         __mode = _CAMERA_MODE_IMAGE;
 852                         if (callback)
 853                         {
 854                                 r = NotifyModeChangePrepared(mode);
 855                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 856                         }
 857                         r = ChangeCameraStateTo(::CAMERA_STATE_PREVIEW);
 858                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 859                         break;
 860
 861                 default:
 862                         break;
 863                 }
 864         }
 865
 866         if (callback)
 867         {
 868                 // Notify that the mode is changed to callback camera and video recorder's configurations.
 869                 r = NotifyModeChanged(mode);
 870                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 871         }
 872
 873         return r;
 874
 875 CATCH:
 876         return r;
 877 }
 878
 879 bool
 880 _CameraCoordinator::IsCalmChangeMode(_CameraMode mode)
 881 {
 882         camera_state_e cameraState = ::CAMERA_STATE_NONE;
 883         recorder_state_e recorderState = ::RECORDER_STATE_NONE;
 884         bool calmChange = false;
 885
 886         if (mode == _CAMERA_MODE_VIDEO)
 887         {
 888                 cameraState = GetCameraState();
 889
 890                 switch (cameraState)
 891                 {
 892                 case ::CAMERA_STATE_CREATED:
 893                         //fall through
 894                 case ::CAMERA_STATE_NONE:
 895                         calmChange = true;
 896                         break;
 897
 898                 case ::CAMERA_STATE_PREVIEW:
 899                         //fall through
 900                 case ::CAMERA_STATE_CAPTURED:
 901                         //fall through
 902                 case ::CAMERA_STATE_CAPTURING:
 903                         calmChange = false;
 904                         break;
 905
 906                 default:
 907                         break;
 908                 }
 909         }
 910         else if ( mode == _CAMERA_MODE_IMAGE )
 911         {
 912                 recorderState = GetRecorderState();
 913
 914                 // Stop the recorder
 915                 switch (recorderState)
 916                 {
 917                 case ::RECORDER_STATE_NONE:
 918                         //fall through
 919                 case ::RECORDER_STATE_CREATED:
 920                         calmChange = true;
 921                         break;
 922
 923                 case ::RECORDER_STATE_READY:
 924                         //fall through
 925                 case ::RECORDER_STATE_RECORDING:
 926                         //fall through
 927                 case ::RECORDER_STATE_PAUSED:
 928                         calmChange = false;
 929                         break;
 930
 931                 default:
 932                         break;
 933                 }
 934         }
 935
 936         SysLog(NID_MEDIA, "mode:%d, calm:%d", mode, calmChange);
 937         return calmChange;
 938 }
 939
 940
 941 _CameraDeviceType
 942 _CameraCoordinator::GetCameraDevice(void) const
 943 {
 944         return __cameraDevice;
 945 }
 946
 947 camera_state_e
 948 _CameraCoordinator::GetCameraState(void) const
 949 {
 950         result r = E_SUCCESS;
 951         int err = MM_SUCCESS;
 952         camera_state_e state = ::CAMERA_STATE_NONE;
 953
 954         err = camera_get_state(__cameraHandle, &state);
 955         r = ConvertResult(err);
 956         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 957
 958         return state;
 959
 960 CATCH:
 961         return ::CAMERA_STATE_NONE;
 962 }
 963
 964 recorder_state_e
 965 _CameraCoordinator::GetRecorderState(void) const
 966 {
 967         result r = E_SUCCESS;
 968         int err = MM_SUCCESS;
 969         recorder_state_e state = ::RECORDER_STATE_NONE;
 970
 971         err = recorder_get_state(__recorderHandle, &state);
 972         r = ConvertResult(err);
 973         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 974
 975         return state;
 976
 977 CATCH:
 978         return ::RECORDER_STATE_NONE;
 979 }
 980
 981 result
 982 _CameraCoordinator::ConvertResult(int err) const
 983 {
 984         result r = E_SYSTEM;
 985         if (err != CAMERA_ERROR_NONE)
 986         {
 987                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
 988         }
 989
 990         // Global error
 991         if (err == CAMERA_ERROR_NONE || err == RECORDER_ERROR_NONE)
 992         {
 993                 r = E_SUCCESS;
 994         }
 995         else if (err == CAMERA_ERROR_INVALID_PARAMETER || err == RECORDER_ERROR_INVALID_PARAMETER)
 996         {
 997                 r = E_INVALID_ARG;
 998         }
 999         else if (err == CAMERA_ERROR_INVALID_STATE || err == RECORDER_ERROR_INVALID_STATE)
1000         {
1001                 r = E_INVALID_STATE;
1002         }
1003         else if (err == CAMERA_ERROR_OUT_OF_MEMORY || err == RECORDER_ERROR_OUT_OF_MEMORY)
1004         {
1005                 r = E_OUT_OF_MEMORY;
1006         }
1007         else if (err == CAMERA_ERROR_DEVICE || err == RECORDER_ERROR_DEVICE)
1008         {
1009                 r = E_DEVICE_FAILED;
1010         }
1011         else if (err == CAMERA_ERROR_INVALID_OPERATION
1012                         || err == CAMERA_ERROR_SECURITY_RESTRICTED
1013                         || err == RECORDER_ERROR_INVALID_OPERATION
1014                         || err == RECORDER_ERROR_SECURITY_RESTRICTED)
1015         {
1016                 r = E_SYSTEM;
1017         }
1018         else if (err == CAMERA_ERROR_DEVICE_BUSY
1019                         || err == CAMERA_ERROR_SOUND_POLICY
1020                         || err == RECORDER_ERROR_SOUND_POLICY)
1021         {
1022                 r = E_DEVICE_BUSY;
1023         }
1024         else if (err == CAMERA_ERROR_DEVICE_NOT_FOUND)
1025         {
1026                 r = E_DEVICE_UNAVAILABLE;
1027         }
1028         else
1029         {
1030                 r = E_UNKNOWN;
1031         }
1032
1033         return r;
1034 }
1035
1036
1037 result
1038 _CameraCoordinator::ChangeCameraStateTo(camera_state_e destState)
1039 {
1040         result r = E_SUCCESS;
1041         int tableTotalCount = 0;
1042         int i = 0;
1043         int err = MM_SUCCESS;
1044         camera_state_e preState = ::CAMERA_STATE_NONE;
1045         camera_state_e postState = ::CAMERA_STATE_NONE;
1046
1047         preState = GetCameraState();
1048         tableTotalCount = sizeof(_CAMERA_STATE_TRANSIT) / sizeof(_CAMERA_STATE_TRANSIT[0]);
1049         SysLog(NID_MEDIA, " PreState:%d, destState:%d, tableTotalCount:%d", preState, destState, tableTotalCount);
1050
1051         for (i = 0; i < tableTotalCount; i++)
1052         {
1053                 if (preState == _CAMERA_STATE_TRANSIT[i].prevState && destState == _CAMERA_STATE_TRANSIT[i].postState)
1054                 {
1055                         if (_CAMERA_STATE_TRANSIT[i].pFunc != null)
1056                         {
1057                                 SysLog(NID_MEDIA,
1058                                                         "Exist the matching state field. loop i:%d, current state:%d, destState:%d", i,
1059                                                         preState, destState);
1060                                 err = _CAMERA_STATE_TRANSIT[i].pFunc(__cameraHandle);
1061                                 r = ConvertResult(err);
1062                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1063
1064                                 // Check whether the retuned states are destinationed states.
1065                                 postState = GetCameraState();
1066                                 SysTryCatch(NID_MEDIA, destState == postState, r = E_INVALID_STATE, E_INVALID_STATE,
1067                                                    "[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,
1068                                                    destState);
1069                                 SysLog(NID_MEDIA, "[E_SUCCESS] Found. result postState:%d, param destState:%d", postState,
1070                                                         destState);
1071                         }
1072                         break;
1073                 }
1074
1075         }
1076         SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
1077         return r;
1078
1079 CATCH:
1080         SysLog(NID_MEDIA, "[%s] Real preState:%d, param destState:%d", GetErrorMessage(r), preState, destState);
1081         return r;
1082 }
1083
1084 result
1085 _CameraCoordinator::ChangeRecorderStateTo(recorder_state_e destState)
1086 {
1087         result r = E_SUCCESS;
1088         int tableTotalCount = 0;
1089         int i = 0;
1090         int err = MM_SUCCESS;
1091         recorder_state_e preState = ::RECORDER_STATE_NONE;
1092         recorder_state_e postState = ::RECORDER_STATE_NONE;
1093
1094         preState = GetRecorderState();
1095         tableTotalCount = sizeof(_RECORDER_STATE_TRANSIT) / sizeof(_RECORDER_STATE_TRANSIT[0]);
1096         SysLog(NID_MEDIA, " PreState:%d, destState:%d, tableTotalCount:%d", preState, destState, tableTotalCount);
1097
1098         for (i = 0; i < tableTotalCount; i++)
1099         {
1100                 if (preState == _RECORDER_STATE_TRANSIT[i].prevState && destState == _RECORDER_STATE_TRANSIT[i].postState)
1101                 {
1102                         if (_RECORDER_STATE_TRANSIT[i].pFunc != null)
1103                         {
1104                                 SysLog(NID_MEDIA,
1105                                                         "Exist the matching state field. loop i:%d, current state:%d, destState:%d", i,
1106                                                         preState, destState);
1107                                 err = _RECORDER_STATE_TRANSIT[i].pFunc(__recorderHandle);
1108                                 r = ConvertResult(err);
1109                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating. i:%d", GetErrorMessage(r), i);
1110
1111                                 // Check whether the retuned states are destinationed states.
1112                                 postState = GetRecorderState();
1113                                 SysTryCatch(NID_MEDIA, destState == postState, r = E_INVALID_STATE, E_INVALID_STATE,
1114                                                    "[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,
1115                                                    destState);
1116                                 SysLog(NID_MEDIA, "[E_SUCCESS] Found. result preState:%d, param destState:%d", postState,
1117                                                         destState);
1118                         }
1119                         break;
1120                 }
1121
1122         }
1123         SysTryCatch(NID_MEDIA, i != tableTotalCount, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Not found. ");
1124         return r;
1125
1126 CATCH:
1127         SysLog(NID_MEDIA, "[%s] Real preState:%d, param destState:%d", GetErrorMessage(r), preState, destState);
1128         return r;
1129 }
1130
1131 result
1132 _CameraCoordinator::SetCameraSourceFormat(camera_pixel_format_e pixelFormat)
1133 {
1134         result r = E_SUCCESS;
1135         int err = MM_SUCCESS;
1136         SysLog(NID_MEDIA, "Camera_pixel_format_e is :%d", pixelFormat);
1137
1138         err = camera_set_preview_format(__cameraHandle, pixelFormat);
1139         r = ConvertResult(err);
1140         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating, pixelFormat:%d", GetErrorMessage(r), pixelFormat);
1141
1142         return r;
1143
1144 CATCH:
1145         return r;
1146 }
1147
1148 camera_pixel_format_e
1149 _CameraCoordinator::GetCameraSourceFormat(void) const
1150 {
1151         result r = E_SUCCESS;
1152         int err = MM_SUCCESS;
1153         camera_pixel_format_e pixelFormat = CAMERA_PIXEL_FORMAT_INVALID;
1154
1155         err = camera_get_preview_format(__cameraHandle, &pixelFormat);
1156         r = ConvertResult(err);
1157         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
1158
1159         return pixelFormat;
1160
1161 CATCH:
1162         return pixelFormat;
1163 }
1164
1165 result
1166 _CameraCoordinator::StartCapture(camera_capturing_cb capturingCb , camera_capture_completed_cb completedCb , void *pUserData)
1167 {
1168         result r = E_SUCCESS;
1169         int err = MM_SUCCESS;
1170
1171         if (__orientationFlag & _ORIENTATION_FOR_CAMERA)
1172         {
1173                 r = SetCameraOrientationAttr(__cameraOrientation);
1174                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1175         }
1176         else if (__orientationFlag & _ORIENTATION_FOR_RECORDING)        // If recorder setting is remained.
1177         {
1178                 r = SetCameraOrientationAttr(CAMERA_EXIF_ORIENTATION_TOP_LEFT); // To set the init value
1179                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1180         }
1181
1182         __mode = _CAMERA_MODE_IMAGE;
1183         err = camera_start_capture(__cameraHandle, capturingCb, completedCb, pUserData);
1184         r = ConvertResult(err);
1185         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Camera capture failed.", GetErrorMessage(r));
1186
1187         return r;
1188 }
1189
1190 result
1191 _CameraCoordinator::StartRecord(void)
1192 {
1193         result r = E_SUCCESS;
1194         int err = MM_SUCCESS;
1195
1196         if (__orientationFlag & _ORIENTATION_FOR_RECORDING)
1197         {
1198                 r = SetRecordingOrientationAttr(__recordingRotation);
1199                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1200         }
1201         else if (__orientationFlag & _ORIENTATION_FOR_CAMERA)   // If recorder setting is remained.
1202         {
1203                 r = SetRecordingOrientationAttr(RECORDING_ROTATION_NONE);       // To set the init value
1204                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1205         }
1206
1207         __mode = _CAMERA_MODE_VIDEO;
1208         err = recorder_start(__recorderHandle);
1209         r = ConvertResult(err);
1210         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Recorder record failed.", GetErrorMessage(r));
1211
1212         return r;
1213 }
1214
1215 void
1216 _CameraCoordinator::SetRecordingOrientation(RecordingRotation rotation)
1217 {
1218         __orientationFlag = __orientationFlag | _ORIENTATION_FOR_RECORDING;
1219         __recordingRotation = rotation;
1220 }
1221
1222 void
1223 _CameraCoordinator::SetCameraOrientation(CameraExifOrientation orientation)
1224 {
1225         __orientationFlag = __orientationFlag | _ORIENTATION_FOR_CAMERA;
1226         __cameraOrientation = orientation;
1227 }
1228
1229 result
1230 _CameraCoordinator::SetRecordingOrientationAttr(RecordingRotation rotation)
1231 {
1232         result r = E_SUCCESS;
1233         int err = MM_SUCCESS;
1234 #if _VIDEO_RECORDER_ROTATION_
1235         recorder_rotation_e mmAttr = ::RECORDER_ROTATION_NONE;
1236         r = _RecorderUtil::GetMmRotation(rotation, mmAttr);
1237         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), rotation);
1238
1239         err = recorder_attr_set_recording_orientation(__recorderHandle, mmAttr);
1240         r = ConvertResult(err);
1241         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Camcorder set attribute failed. rotation:%d", GetErrorMessage(r), rotation);
1242 #else
1243         CameraRotation cameraRotation = CAMERA_ROTATION_NONE;
1244         r = _RecorderUtil::GetCameraRotation(rotation, cameraRotation);
1245         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), rotation);
1246
1247         camera_attr_tag_orientation_e mmOrientationAttr = CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT;
1248         r = _CameraUtil::GetMmExifOrientation(cameraRotation, mmOrientationAttr);
1249         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. rotation:%d", GetErrorMessage(r), rotation);
1250
1251         err = camera_attr_set_tag_orientation(__cameraHandle, mmOrientationAttr);
1252         r = ConvertResult(err);
1253         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Camcorder set attribute failed. Mm orientation:%d", GetErrorMessage(r), mmOrientationAttr);
1254 #endif
1255
1256         return r;
1257 }
1258
1259 result
1260 _CameraCoordinator::SetCameraOrientationAttr(CameraExifOrientation orientation)
1261 {
1262         result r = E_SUCCESS;
1263         int err = MM_SUCCESS;
1264         camera_attr_tag_orientation_e attr = ::CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT;
1265
1266         r = _CameraUtil::GetMmExifOrientation(orientation, attr);
1267         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. orientation:%d", GetErrorMessage(r), orientation);
1268
1269         err = camera_attr_set_tag_orientation(__cameraHandle, attr);
1270         r = ConvertResult(err);
1271         SysTryReturn(NID_MEDIA, r == E_SUCCESS, r, r, "[%s] Propagating. orientation:%d", GetErrorMessage(r), orientation);
1272
1273         return r;
1274 }
1275
1276 camera_pixel_format_e
1277 _CameraCoordinator::GetReloadPreviewFormat(void) const
1278 {
1279         SysLog(NID_MEDIA, "reloadCameraPreviewFormat is :%d", __reloadCameraPreviewFormat);
1280         return __reloadCameraPreviewFormat;
1281 }
1282 }}