src/FMedia_RecorderManager.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_RecorderManager.cpp
  20  * @brief                       This file contains the implementation of the %_RecorderManager class.
  21  *
  22  */
  23
  24 #include <unique_ptr.h>
  25 #include <pthread.h>
  26 #include <recorder.h>
  27 #include <FBaseSysLog.h>
  28 #include "FMedia_CameraManager.h"
  29 #include "FMedia_RecorderManager.h"
  30 #include "FMedia_RecorderTypes.h"
  31
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Base::Collection;
  34
  35 namespace Tizen { namespace Media
  36 {
  37
  38 _RecorderManagerSafeHashMapT* _RecorderManager::__pMap = null;
  39
  40 _RecorderManagerSafeHashMapT::_RecorderManagerSafeHashMapT(void)
  41 {
  42 }
  43
  44 _RecorderManagerSafeHashMapT::~_RecorderManagerSafeHashMapT(void)
  45 {
  46         RemoveItems();
  47         _RecorderManager::__pMap = null;
  48 }
  49
  50 void
  51 _RecorderManagerSafeHashMapT::RemoveItems(void)
  52 {
  53         IListT <_RecorderDeviceType>* pList = null;
  54         _RecorderManager* pManager = null;
  55         result r = E_SUCCESS;
  56
  57         pList = GetKeysN();
  58         SysTryReturnVoidResult(NID_MEDIA, pList != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] There is no instance.");
  59
  60         for (int i = 0; i < GetCount(); i++)
  61         {
  62                 _RecorderDeviceType deviceType = _RECORDER_DEVICE_NONE;
  63                 r = pList->GetAt(i, deviceType);
  64                 if (IsFailed(r) && deviceType == _RECORDER_DEVICE_NONE)
  65                 {
  66                         continue;
  67                 }
  68
  69                 r = GetValue(deviceType, pManager);
  70                 if (IsFailed(r) && pManager == null)
  71                 {
  72                         continue;
  73                 }
  74                 delete pManager;
  75         }
  76         pList->RemoveAll();
  77         delete pList;
  78         RemoveAll();
  79 }
  80
  81 _RecorderManager::_RecorderManager()
  82         : __handle(MM_INVALID_HANDLE)
  83 {
  84 }
  85
  86 _RecorderManager::~_RecorderManager()
  87 {
  88         result r = E_SUCCESS;
  89         int err = MM_SUCCESS;
  90
  91         err = recorder_destroy(__handle);
  92         r = ConvertResult(err);
  93         SysLog(NID_MEDIA, "[%s] destroyed.", GetErrorMessage(r));
  94 }
  95
  96 result
  97 _RecorderManager::Construct(_CameraDeviceType cameraDevice, _RecorderDeviceType recorderDevice)
  98 {
  99         result r = E_SUCCESS;
 100         int err = MM_SUCCESS;
 101         SysLog(NID_MEDIA, "Enter. camera device:%d, recorder device:%d", (int)cameraDevice, (int)recorderDevice);
 102
 103         if (recorderDevice == _RECORDER_DEVICE_AUDIO)
 104         {
 105                 err = recorder_create_audiorecorder(&__handle);
 106                 r = ConvertResult(err);
 107                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 108         }
 109         else if (recorderDevice == _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA || recorderDevice == _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA)
 110         {
 111                 _CameraManager* pCameraManager = null;
 112                 _CameraHandle cameraHandle = 0;
 113
 114                 pCameraManager = _CameraManager::AddInstance(cameraDevice);
 115                 SysTryCatch(NID_MEDIA, pCameraManager != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] _CameraHandle instance is not available.");
 116
 117                 cameraHandle = pCameraManager->GetHandle();
 118
 119                 err = recorder_create_videorecorder(cameraHandle, &__handle);
 120                 r = ConvertResult(err);
 121                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 122         }
 123         else
 124         {
 125                 SysLogException(NID_MEDIA, r = E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(cameraDevice, recorderDevice) is used. cameraDevice:%d, recorderDevice:%d is wrong.",
 126                         (int)cameraDevice, (int)recorderDevice);
 127                 goto CATCH;
 128         }
 129
 130         return r;
 131
 132 CATCH:
 133         return r;
 134 }
 135
 136 void
 137 _RecorderManager::InitSafeHashMapInst()
 138 {
 139         static _RecorderManagerSafeHashMapT map;
 140         result r = E_SUCCESS;
 141
 142         r = map.Construct();
 143         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 144
 145         __pMap = &map;
 146         return;
 147 CATCH:
 148         __pMap = null;
 149 }
 150
 151 _RecorderManager*
 152 _RecorderManager::AddInstance(_RecorderDeviceType recorderDevice)
 153 {
 154         result r = E_SUCCESS;
 155         bool out = false;
 156         _RecorderManager* pManager = null;
 157
 158         SysTryReturn(NID_MEDIA, recorderDevice > _RECORDER_DEVICE_NONE && recorderDevice < _RECORDER_DEVICE_MAX,
 159                                 null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(recorderDevice) is used. recorderDevice:%d.", (int) recorderDevice);
 160
 161         static pthread_once_t once_block = PTHREAD_ONCE_INIT;
 162
 163         if (!__pMap)
 164         {
 165                 pthread_once(&once_block, InitSafeHashMapInst);
 166                 r = GetLastResult();
 167                 SysTryReturn(NID_MEDIA, __pMap != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 168         }
 169
 170         r = __pMap->ContainsKey(recorderDevice, out);
 171         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 172
 173         if (out)
 174         {
 175                 r = __pMap->GetValue(recorderDevice, pManager);
 176                 SysTryReturn(NID_MEDIA, r == E_SUCCESS && pManager != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 177         }
 178         else
 179         {
 180                 _CameraDeviceType cameraDevice = _CAMERA_DEVICE_NONE;
 181                 switch (recorderDevice)
 182                 {
 183                 case _RECORDER_DEVICE_VIDEO_PRIMARY_CAMERA:
 184                         cameraDevice = _CAMERA_DEVICE_PRIMARY;
 185                         break;
 186                 case _RECORDER_DEVICE_VIDEO_SECONDARY_CAMERA:
 187                         cameraDevice = _CAMERA_DEVICE_SECONDARY;
 188                         break;
 189                 default:
 190                         break;
 191                 }
 192
 193                 std::unique_ptr <_RecorderManager> pMan (new (std::nothrow) _RecorderManager());
 194                 SysTryReturn(NID_MEDIA, pMan.get() !=null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The object is not created.");
 195
 196                 r = pMan->Construct(cameraDevice, recorderDevice);
 197                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 198
 199                 r = __pMap->Add(recorderDevice, pMan.get());
 200                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 201
 202                 pManager = pMan.release();
 203         }
 204
 205         pManager->AddRefCount();
 206         return pManager;
 207 }
 208
 209 void
 210 _RecorderManager::Release(_RecorderDeviceType recorderDevice)
 211 {
 212         result r = E_SUCCESS;
 213
 214         if (__pMap != null)
 215         {
 216                 _RecorderManager* pManager = null;
 217                 r = __pMap->GetValue(recorderDevice, pManager);
 218                 SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 219
 220                 if (pManager->ReleaseRefCount() == 0)
 221                 {
 222                         delete pManager;
 223                         r = __pMap->Remove(recorderDevice);
 224                         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 225                 }
 226         }
 227 }
 228
 229 _RecorderManager*
 230 _RecorderManager::HasInstance(_RecorderDeviceType recorderDevice)
 231 {
 232         result r = E_SUCCESS;
 233         _RecorderManager* pManager = null;
 234
 235         if (__pMap != null)
 236         {
 237                 r = __pMap->GetValue(recorderDevice, pManager);
 238                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 239         }
 240         return pManager;
 241 }
 242
 243 _RecorderHandle
 244 _RecorderManager::GetHandle(void) const
 245 {
 246         return __handle;
 247 }
 248
 249 result
 250 _RecorderManager::ConvertResult(int err) const
 251 {
 252         result r = E_SYSTEM;
 253         if (err != ::RECORDER_ERROR_NONE)
 254         {
 255                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
 256         }
 257
 258         // Global error
 259         if (err == ::RECORDER_ERROR_NONE)
 260         {
 261                 r = E_SUCCESS;
 262         }
 263         else if (err == ::RECORDER_ERROR_INVALID_PARAMETER)
 264         {
 265                 r = E_INVALID_ARG;
 266         }
 267         else if (err == ::RECORDER_ERROR_INVALID_STATE)
 268         {
 269                 r = E_INVALID_STATE;
 270         }
 271         else if (err == ::RECORDER_ERROR_OUT_OF_MEMORY)
 272         {
 273                 r = E_OUT_OF_MEMORY;
 274         }
 275         else if (err == ::RECORDER_ERROR_DEVICE)
 276         {
 277                 r = E_DEVICE_FAILED;
 278         }
 279         else if (err == ::RECORDER_ERROR_INVALID_OPERATION
 280                 || err == ::RECORDER_ERROR_SOUND_POLICY
 281                 || err == ::RECORDER_ERROR_SECURITY_RESTRICTED)
 282         {
 283                 r = E_SYSTEM;
 284         }
 285         else
 286         {
 287                 r = E_UNKNOWN;
 288         }
 289
 290         return r;
 291 }
 292
 293 }}// Tizen::Media