src/FMedia_RecorderSession.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_RecorderSession.cpp
  20  * @brief                       This file contains the implementation of the %_RecorderSession class.
  21  *
  22  */
  23
  24 #include <FBaseSysLog.h>
  25 #include "FMedia_RecorderManager.h"
  26 #include "FMedia_RecorderSession.h"
  27 #include "FMedia_CameraTypes.h"
  28 #include "FMedia_CameraCoordinator.h"
  29 #include "FMedia_CapabilityImpl.h"
  30
  31 using namespace Tizen::Base;
  32
  33 namespace Tizen { namespace Media
  34 {
  35
  36 _RecorderSession::_RecorderSession(void)
  37         : __previousCameraMode(_CAMERA_MODE_NONE)
  38         , __recorderDevice(_RECORDER_DEVICE_NONE)
  39         , __handle(MM_INVALID_HANDLE)
  40         , __pCoordinator(null)
  41 {
  42 }
  43
  44 _RecorderSession::~_RecorderSession(void)
  45 {
  46         result r = E_SUCCESS;
  47
  48         if (__recorderDevice == _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA ||__recorderDevice == _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA)
  49         {
  50                 if (__pCoordinator)
  51                 {
  52                         if (__previousCameraMode == _CAMERA_MODE_IMAGE)
  53                         {
  54                                 r = __pCoordinator->DestroyVideoRecorder();
  55                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  56                         }
  57                         SysLog(NID_MEDIA, "Release the recorder device:%d", __recorderDevice);
  58                         _CameraCoordinator::Release(__recorderDevice);
  59                 }
  60         }
  61         else if (__recorderDevice == _RECORDER_DEVICE_AUDIO)
  62         {
  63                 SysLog(NID_MEDIA, "Release the audio recorder.");
  64                 _RecorderManager::Release(__recorderDevice);
  65         }
  66         return;
  67
  68 CATCH:
  69         SysLogException(NID_MEDIA, r, "[%s] Error while deleting recorder session", GetErrorMessage(r));
  70 }
  71
  72 result
  73 _RecorderSession::Construct(_RecorderDeviceType recorderDevice)
  74 {
  75         result r = E_SUCCESS;
  76         SysLog(NID_MEDIA, "Enter. recorder device:%d", recorderDevice);
  77
  78         if (recorderDevice == _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA ||recorderDevice == _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA)
  79         {
  80                 __pCoordinator = _CameraCoordinator::AddInstance(recorderDevice);
  81                 SysTryCatch(NID_MEDIA, __pCoordinator != null, , E_SYSTEM, "[E_SYSTEM] The camera coordinator is null.");
  82
  83                 if (__pCoordinator->GetMode() == _CAMERA_MODE_IMAGE)
  84                 {
  85                         r = __pCoordinator->CreateVideoRecorder();
  86                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  87                         __previousCameraMode = _CAMERA_MODE_IMAGE;
  88                 }
  89                 __handle = __pCoordinator->GetRecorderHandle();
  90         }
  91         else if (recorderDevice == _RECORDER_DEVICE_AUDIO)
  92         {
  93                 _RecorderManager* pRecorderManager = null;
  94
  95                 pRecorderManager = _RecorderManager::AddInstance(recorderDevice);
  96                 r = GetLastResult();
  97                 SysTryCatch(NID_MEDIA, pRecorderManager !=null, , r, "[%s] Propagating.", GetErrorMessage(r));
  98
  99                 __handle = pRecorderManager->GetHandle();
 100         }
 101
 102         __recorderDevice = recorderDevice;
 103         return r;
 104
 105 CATCH:
 106         __previousCameraMode = _CAMERA_MODE_NONE;
 107         return r;
 108 }
 109
 110 result
 111 _RecorderSession::Construct(_RecorderSourceType recorderSource)
 112 {
 113         result r = E_SUCCESS;
 114         _CameraDeviceType runningCamera = _CAMERA_DEVICE_NONE;
 115         _RecorderDeviceType targetRecorder = _RECORDER_DEVICE_NONE;
 116         SysLog(NID_MEDIA, "Enter.");
 117
 118         int cameraCount = 0;
 119         _CapabilityImpl* pCapabilityImpl = _CapabilityImpl::GetInstance();
 120         SysTryReturn(NID_MEDIA, pCapabilityImpl != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. Capability is not obtained.");
 121         SysTryReturn(NID_MEDIA, cameraCount < 1, E_DEVICE_UNAVAILABLE, E_DEVICE_UNAVAILABLE, "[E_DEVICE_UNAVAILABLE] The camera(%d) is not available.", cameraCount);
 122
 123         r = pCapabilityImpl->GetValue(L"Camera.Count", cameraCount);
 124         SysTryReturn(NID_MEDIA, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has been occurred. Number of Camera was not obtained.");
 125
 126         if (recorderSource == _RECORDER_SOURCE_VIDEO)
 127         {
 128                 if (_CameraCoordinator::HasInstance(_RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA) != null)
 129                 {
 130                         runningCamera = _CAMERA_DEVICE_PRIMARY;
 131                 }
 132                 else if (_CameraCoordinator::HasInstance(_RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA) != null)
 133                 {
 134                         runningCamera = _CAMERA_DEVICE_SECONDARY;
 135                 }
 136                 else
 137                 {
 138                         runningCamera = _CAMERA_DEVICE_PRIMARY;
 139                 }
 140                 __pCoordinator = _CameraCoordinator::AddInstance(runningCamera);
 141                 SysTryCatch(NID_MEDIA, __pCoordinator != null, , E_SYSTEM, "[E_SYSTEM] The camera coordinator is null.");
 142
 143                 if (__pCoordinator->GetMode() == _CAMERA_MODE_IMAGE)
 144                 {
 145                         if (cameraCount < 2)
 146                         {
 147                                 targetRecorder = (runningCamera == _CAMERA_DEVICE_PRIMARY ? _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA);
 148                                 r = __pCoordinator->CreateVideoRecorder();
 149                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 150                                 __previousCameraMode = _CAMERA_MODE_IMAGE;
 151                         }
 152                         else
 153                         {
 154                                 if(__pCoordinator->IsCalmChangeMode(_CAMERA_MODE_VIDEO))
 155                                 {
 156                                         targetRecorder = (runningCamera == _CAMERA_DEVICE_PRIMARY ? _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA);
 157                                         r = __pCoordinator->CreateVideoRecorder();
 158                                         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 159                                         __previousCameraMode = _CAMERA_MODE_IMAGE;
 160                                 }
 161                                 else
 162                                 {
 163                                         // If the current coordinator(camera) is not proper state to get the recorder without flickering.
 164                                         _CameraCoordinator::Release(runningCamera);
 165
 166                                         // Pick the other camera for the recorder
 167                                         targetRecorder = (runningCamera == _CAMERA_DEVICE_PRIMARY ? _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA : _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA);
 168
 169                                         // Get the other coordinator(camera)
 170                                         __pCoordinator = _CameraCoordinator::AddInstance(targetRecorder);
 171                                         SysTryCatch(NID_MEDIA, __pCoordinator != null, , E_SYSTEM, "[E_SYSTEM] The camera coordinator is null.");
 172
 173                                         if(__pCoordinator->IsCalmChangeMode(_CAMERA_MODE_VIDEO))
 174                                         {
 175                                                 r = __pCoordinator->CreateVideoRecorder();
 176                                                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 177                                                 __previousCameraMode = _CAMERA_MODE_IMAGE;
 178                                         }
 179                                         else
 180                                         {
 181                                                 SysLogException(NID_MEDIA, E_SYSTEM, "[E_SYSTEM] Both cameras' state are not proper to change mode.");
 182                                                 goto CATCH;
 183                                         }
 184                                 }
 185                         }
 186                 }
 187                 else if (__pCoordinator->GetMode() == _CAMERA_MODE_VIDEO)
 188                 {
 189                         targetRecorder = (runningCamera == _CAMERA_DEVICE_PRIMARY ? _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA : _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA);
 190                         __previousCameraMode = _CAMERA_MODE_VIDEO;
 191                 }
 192                 else
 193                 {
 194                         SysLogException(NID_MEDIA, E_SYSTEM, "[E_SYSTEM] Camera is not working properly.");
 195                         goto CATCH;
 196                 }
 197                 __handle = __pCoordinator->GetRecorderHandle();
 198                 __recorderDevice = targetRecorder;
 199         }
 200         else if (recorderSource == _RECORDER_SOURCE_AUDIO)
 201         {
 202                 _RecorderManager* pRecorderManager = null;
 203
 204                 pRecorderManager = _RecorderManager::AddInstance(_RECORDER_DEVICE_AUDIO);
 205                 r = GetLastResult();
 206                 SysTryCatch(NID_MEDIA, pRecorderManager !=null, , r, "[%s] Propagating.", GetErrorMessage(r));
 207
 208                 __handle = pRecorderManager->GetHandle();
 209                 __recorderDevice = _RECORDER_DEVICE_AUDIO;
 210         }
 211
 212         return r;
 213 CATCH:
 214         return r;
 215 }
 216
 217 _RecorderHandle
 218 _RecorderSession::GetHandle(void)
 219 {
 220         return __handle;
 221 }
 222
 223 }}// Tizen::Media