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 <pthread.h>
  25 #include <camera.h>
  26 #include <FBaseSysLog.h>
  27 #include "FMedia_CameraManager.h"
  28
  29 #define MM_SUCCESS 0
  30
  31 using namespace Tizen::Base;
  32 using namespace Tizen::Base::Collection;
  33
  34 namespace Tizen { namespace Media
  35 {
  36 _CameraManagerSafeHashMapT* _CameraManager::__pMap = null;
  37
  38 _CameraManagerSafeHashMapT::_CameraManagerSafeHashMapT(void)
  39 {
  40 }
  41
  42 _CameraManagerSafeHashMapT::~_CameraManagerSafeHashMapT(void)
  43 {
  44         RemoveItems();
  45         _CameraManager::__pMap = null;
  46 }
  47
  48 void
  49 _CameraManagerSafeHashMapT::RemoveItems(void)
  50 {
  51         IListT <_CameraDeviceType>* pList = null;
  52         _CameraManager* pManager = null;
  53         result r = E_SUCCESS;
  54
  55         pList = GetKeysN();
  56         SysTryReturn(NID_MEDIA, pList != null, , E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] There is no instance.");
  57
  58         for (int i = 0; i < GetCount(); i++)
  59         {
  60                 _CameraDeviceType deviceType = _CAMERA_DEVICE_NONE;
  61                 r = pList->GetAt(i, deviceType);
  62                 if (IsFailed(r) && deviceType == _CAMERA_DEVICE_NONE)
  63                 {
  64                         continue;
  65                 }
  66
  67                 r = GetValue(deviceType, pManager);
  68                 if (IsFailed(r) && pManager == null)
  69                 {
  70                         continue;
  71                 }
  72                 delete pManager;
  73         }
  74         pList->RemoveAll();
  75         delete pList;
  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::InitSafeHashMapInst()
 116 {
 117         static _CameraManagerSafeHashMapT map;
 118         result r = E_SUCCESS;
 119
 120         r = map.Construct();
 121         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 122
 123         __pMap = &map;
 124         return;
 125 CATCH:
 126         __pMap = null;
 127 }
 128
 129 _CameraManager*
 130 _CameraManager::AddInstance(_CameraDeviceType cameraDevice)
 131 {
 132         result r = E_SUCCESS;
 133         bool out = false;
 134
 135         _CameraManager* pManager = null;
 136
 137         SysTryReturn(NID_MEDIA, cameraDevice > _CAMERA_DEVICE_NONE && cameraDevice < _CAMERA_DEVICE_MAX,
 138                                 null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(cameraDevice) is used. camderDevice:%d is wrong.", cameraDevice);
 139
 140         static pthread_once_t once_block = PTHREAD_ONCE_INIT;
 141
 142         if (!__pMap)
 143         {
 144                 pthread_once(&once_block, InitSafeHashMapInst);
 145                 r = GetLastResult();
 146                 SysTryCatch(NID_MEDIA, __pMap != null, , r, "[%s] Propagating.", GetErrorMessage(r));
 147         }
 148
 149         r = __pMap->ContainsKey(cameraDevice, out);
 150         SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 151
 152         if (out)
 153         {
 154                 r = __pMap->GetValue(cameraDevice, pManager);
 155                 SysTryCatch(NID_MEDIA, r == E_SUCCESS && pManager != null, , r, "[%s] Propagating.", GetErrorMessage(r));
 156         }
 157         else
 158         {
 159                 pManager = new (std::nothrow) _CameraManager();
 160                 SysTryCatch(NID_MEDIA, pManager !=null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.  The object is not created.");
 161
 162                 r = pManager->Construct(cameraDevice);
 163                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 164
 165                 r = __pMap->Add(cameraDevice, pManager);
 166                 SysTryCatch(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 167         }
 168
 169         return pManager;
 170
 171 CATCH:
 172         if (pManager != null)
 173         {
 174                 delete pManager;
 175         }
 176         return null;
 177 }
 178
 179 void
 180 _CameraManager::Release(_CameraDeviceType cameraDevice)
 181 {
 182         result r = E_SUCCESS;
 183
 184         if (__pMap != null)
 185         {
 186                 _CameraManager* pManager = null;
 187                 r = __pMap->GetValue(cameraDevice, pManager);
 188                 SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 189
 190                 if (pManager->ReleaseRefCount() == 0)
 191                 {
 192                         delete pManager;
 193                         r = __pMap->Remove(cameraDevice);
 194                         SysTryReturn(NID_MEDIA, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 195                 }
 196         }
 197 }
 198
 199 _CameraHandle
 200 _CameraManager::GetHandle(void) const
 201 {
 202         return __handle;
 203 }
 204
 205 result
 206 _CameraManager::ConvertResult(int err) const
 207 {
 208         result r = E_SYSTEM;
 209         if (err != ::CAMERA_ERROR_NONE)
 210         {
 211                 SysLog(NID_MEDIA, "MM Err:0x%x", err);
 212         }
 213
 214         // Global error
 215         if (err == ::CAMERA_ERROR_NONE)
 216         {
 217                 r = E_SUCCESS;
 218         }
 219         else if (err == ::CAMERA_ERROR_INVALID_PARAMETER)
 220         {
 221                 r = E_INVALID_ARG;
 222         }
 223         else if (err == ::CAMERA_ERROR_INVALID_STATE)
 224         {
 225                 r = E_INVALID_STATE;
 226         }
 227         else if (err == ::CAMERA_ERROR_OUT_OF_MEMORY)
 228         {
 229                 r = E_OUT_OF_MEMORY;
 230         }
 231         else if (err == ::CAMERA_ERROR_DEVICE)
 232         {
 233                 r = E_DEVICE_FAILED;
 234         }
 235         else if (err == ::CAMERA_ERROR_INVALID_OPERATION
 236                         || err == ::CAMERA_ERROR_SOUND_POLICY
 237                         || err == ::CAMERA_ERROR_SECURITY_RESTRICTED)
 238         {
 239                 r = E_SYSTEM;
 240         }
 241         else if (err == ::CAMERA_ERROR_DEVICE_BUSY)
 242         {
 243                 r = E_DEVICE_BUSY;
 244         }
 245         else if (err == ::CAMERA_ERROR_DEVICE_NOT_FOUND)
 246         {
 247                 r = E_DEVICE_UNAVAILABLE;
 248         }
 249         else
 250         {
 251                 r = E_UNKNOWN;
 252         }
 253
 254         return r;
 255 }
 256
 257 }}// Tizen::Media