src/FMedia_CameraManager.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_CameraManager.cpp
  20  * @brief                       This file contains the implementation of the %_CameraManager class.
  21  *
  22  */
  23
  24 #include <unique_ptr.h>
  25 #include <pthread.h>
  26 #include <camera.h>
  27 #include <FBaseSysLog.h>
  28 #include "FMedia_CameraManager.h"
  29 #include "FMedia_CameraManager.h"
  30 #include "FMedia_CamPtrUtil.h"
  31
  32 #define MM_SUCCESS 0
  33
  34 using namespace Tizen::Base;
  35 using namespace Tizen::Base::Collection;
  36
  37 namespace Tizen { namespace Media
  38 {
  39 _CameraManagerSafeHashMapT* _CameraManager::__pMap = null;
  40
  41 _CameraManagerSafeHashMapT::_CameraManagerSafeHashMapT(void)
  42 {
  43 }
  44
  45 _CameraManagerSafeHashMapT::~_CameraManagerSafeHashMapT(void)
  46 {
  47         RemoveItems();
  48         _CameraManager::__pMap = null;
  49 }
  50
  51 void
  52 _CameraManagerSafeHashMapT::RemoveItems(void)
  53 {
  54         _CameraManager* pManager = null;
  55         result r = E_SUCCESS;
  56
  57         std::unique_ptr <IListT<_CameraDeviceType>, _ListPtrUtil::Remover > pList (GetKeysN(), _ListPtrUtil::remover);
  58         SysTryReturnVoidResult(NID_MEDIA, pList.get() != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] There is no instance.");
  59
  60         for (int i = 0; i < GetCount(); i++)
  61         {
  62                 _CameraDeviceType deviceType = _CAMERA_DEVICE_NONE;
  63                 r = pList->GetAt(i, deviceType);
  64                 if (IsFailed(r) && deviceType == _CAMERA_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         RemoveAll();
  77 }
  78
  79 _CameraManager::_CameraManager()
  80         : __handle(MM_INVALID_HANDLE)
  81 {
  82 }
  83
  84 _CameraManager::~_CameraManager()
  85 {
  86         result r = E_SUCCESS;
  87         int err = MM_SUCCESS;
  88
  89         err = camera_destroy(__handle);
  90         r = ConvertResult(err);
  91         SysLog(NID_MEDIA, "[%s] destroyed.", GetErrorMessage(r));
  92 }
  93
  94 result
  95 _CameraManager::Construct(_CameraDeviceType cameraDevice)
  96 {
  97         result r = E_SUCCESS;
  98         camera_device_e device = CAMERA_DEVICE_CAMERA0;
  99         int err = MM_SUCCESS;
 100         SysLog(NID_MEDIA, "Enter. device:%d", cameraDevice);
 101
 102         device = cameraDevice == _CAMERA_DEVICE_PRIMARY ? CAMERA_DEVICE_CAMERA0 :  CAMERA_DEVICE_CAMERA1;
 103
 104         err = camera_create(device, &__handle);
 105         r = ConvertResult(err);
 106         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 107
 108         return r;
 109
 110 CATCH:
 111         return r;
 112 }
 113
 114 void
 115 _CameraManager::InitSingleton()
 116 {
 117         result r = E_SUCCESS;
 118         std::unique_ptr <_CameraManagerSafeHashMapT> pMap (new (std::nothrow) _CameraManagerSafeHashMapT());
 119         SysTryReturnVoidResult(NID_MEDIA, pMap.get() != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 120
 121         r = pMap->Construct();
 122         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 123
 124         __pMap = pMap.release();
 125         std::atexit(DestroySingleton);
 126 }
 127
 128 void
 129 _CameraManager::DestroySingleton(void)
 130 {
 131         delete __pMap;
 132 }
 133
 134 _CameraManager*
 135 _CameraManager::AddInstance(_CameraDeviceType cameraDevice)
 136 {
 137         result r = E_SUCCESS;
 138         bool out = false;
 139         _CameraManager* pManager = null;
 140         SysTryReturn(NID_MEDIA, cameraDevice > _CAMERA_DEVICE_NONE && cameraDevice < _CAMERA_DEVICE_MAX,
 141                                 null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(cameraDevice) is used. camderDevice:%d is wrong.", cameraDevice);
 142
 143         static pthread_once_t once_block = PTHREAD_ONCE_INIT;
 144         if (!__pMap)
 145         {
 146                 pthread_once(&once_block, InitSingleton);
 147                 r = GetLastResult();
 148                 SysTryReturn(NID_MEDIA, __pMap != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 149         }
 150
 151         r = __pMap->ContainsKey(cameraDevice, out);
 152         SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 153
 154         if (out)
 155         {
 156                 r = __pMap->GetValue(cameraDevice, pManager);
 157                 SysTryReturn(NID_MEDIA, r == E_SUCCESS && pManager != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 158         }
 159         else
 160         {
 161                 std::unique_ptr <_CameraManager> pMan (new (std::nothrow) _CameraManager());
 162                 SysTryReturn(NID_MEDIA, pMan.get() !=null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 163
 164                 r = pMan->Construct(cameraDevice);
 165                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 166
 167                 r = __pMap->Add(cameraDevice, pMan.get());
 168                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 169
 170                 pManager = pMan.release();
 171         }
 172
 173         return pManager;
 174 }
 175
 176 void
 177 _CameraManager::Release(_CameraDeviceType cameraDevice)
 178 {
 179         result r = E_SUCCESS;
 180
 181         if (__pMap != null)
 182         {
 183                 _CameraManager* pManager = null;
 184                 r = __pMap->GetValue(cameraDevice, pManager);
 185                 SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 186
 187                 if (pManager->ReleaseRefCount() == 0)
 188                 {
 189                         delete pManager;
 190                         r = __pMap->Remove(cameraDevice);
 191                         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 192                 }
 193         }
 194 }
 195
 196 _CameraHandle
 197 _CameraManager::GetHandle(void) const
 198 {
 199         return __handle;
 200 }
 201
 202 result
 203 _CameraManager::ConvertResult(int err) const
 204 {
 205         result r = E_SYSTEM;
 206         if (err != ::CAMERA_ERROR_NONE)
 207         {
 208                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
 209         }
 210
 211         // Global error
 212         if (err == ::CAMERA_ERROR_NONE)
 213         {
 214                 r = E_SUCCESS;
 215         }
 216         else if (err == ::CAMERA_ERROR_INVALID_PARAMETER)
 217         {
 218                 r = E_INVALID_ARG;
 219         }
 220         else if (err == ::CAMERA_ERROR_INVALID_STATE)
 221         {
 222                 r = E_INVALID_STATE;
 223         }
 224         else if (err == ::CAMERA_ERROR_OUT_OF_MEMORY)
 225         {
 226                 r = E_OUT_OF_MEMORY;
 227         }
 228         else if (err == ::CAMERA_ERROR_DEVICE)
 229         {
 230                 r = E_DEVICE_FAILED;
 231         }
 232         else if (err == ::CAMERA_ERROR_INVALID_OPERATION
 233                         || err == ::CAMERA_ERROR_SOUND_POLICY
 234                         || err == ::CAMERA_ERROR_SECURITY_RESTRICTED)
 235         {
 236                 r = E_SYSTEM;
 237         }
 238         else if (err == ::CAMERA_ERROR_DEVICE_BUSY)
 239         {
 240                 r = E_DEVICE_BUSY;
 241         }
 242         else if (err == ::CAMERA_ERROR_DEVICE_NOT_FOUND)
 243         {
 244                 r = E_DEVICE_UNAVAILABLE;
 245         }
 246         else
 247         {
 248                 r = E_UNKNOWN;
 249         }
 250
 251         return r;
 252 }
 253
 254 }}// Tizen::Media