src/FScl_CalendarbookDbMonitor.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  * @file                FScl_CalendarbookDbMonitor.cpp
  19  * @brief               This is the implementation for _CalendarbookDbMonitor class.
  20  *
  21  * This file contains definitions of @e _CalendarbookDbMonitor class.
  22  */
  23
  24 #include <new>
  25 #include <pthread.h>
  26 #include <unique_ptr.h>
  27 #include <calendar2.h>
  28 #include <FBaseRtMutex.h>
  29 #include <FBaseSysLog.h>
  30 #include "FScl_ICalendarbookDbChangeEventListener.h"
  31 #include "FScl_CalendarbookDbChangeEvent.h"
  32 #include "FScl_CalendarbookDbChangeEventArg.h"
  33 #include "FScl_CalendarbookDbMonitor.h"
  34 #include "FScl_CalendarbookDbConnector.h"
  35
  36 using namespace Tizen::Base;
  37 using namespace Tizen::Base::Runtime;
  38
  39 namespace Tizen { namespace Social
  40 {
  41
  42 Mutex _CalendarbookDbMonitor::__mutex;
  43 int _CalendarbookDbMonitor::__refCnt = 0;
  44 _CalendarbookDbMonitor*_CalendarbookDbMonitor::__pCalendarbookDbMonitor = null;
  45
  46 _CalendarbookDbMonitor::_CalendarbookCallback::_CalendarbookCallback(void)
  47         : __callback(null)
  48         , __pUserData(null)
  49         , __isRegistered(false)
  50 {
  51 }
  52
  53 _CalendarbookDbMonitor::_CalendarbookCallback::~_CalendarbookCallback(void)
  54 {
  55         if (__isRegistered)
  56         {
  57                 calendar_db_remove_changed_cb(_calendar_event._uri, __callback, __pUserData);
  58                 calendar_db_remove_changed_cb(_calendar_todo._uri, __callback, __pUserData);
  59         }
  60 }
  61
  62 result
  63 _CalendarbookDbMonitor::_CalendarbookCallback::Register(calendar_db_changed_cb callback, void* pUserData)
  64 {
  65         int errorCode = CALENDAR_ERROR_NONE;
  66
  67         errorCode = calendar_db_add_changed_cb(_calendar_event._uri, callback, pUserData);
  68         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_SYSTEM, "A system error has been occurred.");
  69         errorCode = calendar_db_add_changed_cb(_calendar_todo._uri, callback, pUserData);
  70         SysTryReturnResult(NID_SCL, errorCode == CALENDAR_ERROR_NONE, E_SYSTEM, "A system error has been occurred.");
  71
  72         __callback = callback;
  73         __pUserData = pUserData;
  74         __isRegistered = true;
  75
  76         return E_SUCCESS;
  77 }
  78
  79 _CalendarbookDbMonitor::_CalendarbookDbMonitor(void)
  80 {
  81         // empty body.
  82 }
  83
  84 _CalendarbookDbMonitor::~_CalendarbookDbMonitor(void)
  85 {
  86         result r = _CalendarbookDbConnector::Disconnect();
  87         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
  88 }
  89
  90 result
  91 _CalendarbookDbMonitor::Construct(void)
  92 {
  93         result r = E_SUCCESS;
  94
  95         r = _CalendarbookDbConnector::Connect();
  96         SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "A system error has been occurred.");
  97
  98         std::unique_ptr<_CalendarbookCallback> pChangeCallback(new (std::nothrow) _CalendarbookCallback());
  99         SysTryReturnResult(NID_SCL, pChangeCallback != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 100
 101         r = pChangeCallback->Register(OnCalendarbookDbChanged, this);
 102         SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "A system error has been occurred.");
 103
 104         std::unique_ptr<_CalendarbookDbChangeEvent> pEvent(new (std::nothrow) _CalendarbookDbChangeEvent());
 105         SysTryReturn(NID_SCL, pEvent != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 106
 107         r = pEvent->Construct();
 108         SysTryReturn(NID_SCL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 109
 110         __pEvent = std::move(pEvent);
 111         __pChangeCallback = std::move(pChangeCallback);
 112
 113         return E_SUCCESS;
 114 }
 115
 116 result
 117 _CalendarbookDbMonitor::AddListener(const _ICalendarbookDbChangeEventListener& listener)
 118 {
 119         result r = __mutex.Acquire();
 120         SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "A system error has been occurred.");
 121
 122         r = __pEvent->AddListener(listener);
 123         SysTryCatch(NID_SCL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 124
 125         r = __mutex.Release();
 126         SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "A system error has been occurred.");
 127
 128         return E_SUCCESS;
 129
 130 CATCH:
 131         __mutex.Release();
 132
 133         return r;
 134 }
 135
 136 result
 137 _CalendarbookDbMonitor::RemoveListener(const _ICalendarbookDbChangeEventListener& listener)
 138 {
 139         result r = __mutex.Acquire();
 140         SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "A system error has been occurred.");
 141
 142         r = __pEvent->RemoveListener(listener);
 143         SysTryCatch(NID_SCL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 144
 145         r = __mutex.Release();
 146         SysTryReturnResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "A system error has been occurred.");
 147
 148         return E_SUCCESS;
 149
 150 CATCH:
 151         __mutex.Release();
 152
 153         return r;
 154 }
 155
 156 _CalendarbookDbMonitor*
 157 _CalendarbookDbMonitor::GetInstance(void)
 158 {
 159         result r = E_SUCCESS;
 160         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 161
 162         std::unique_ptr<_CalendarbookDbMonitor> pCalendarbookDbMonitor;
 163
 164         if (__pCalendarbookDbMonitor == null)
 165         {
 166                 ClearLastResult();
 167                 pthread_once(&onceBlock, InitCalendarbookDbMonitor);
 168                 if (GetLastResult() != E_SUCCESS)
 169                 {
 170                         onceBlock = PTHREAD_ONCE_INIT;
 171                         SysLogException(NID_SCL, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
 172                         return null;
 173                 }
 174
 175                 pCalendarbookDbMonitor.reset(new (std::nothrow) _CalendarbookDbMonitor());
 176                 SysTryReturn(NID_SCL, pCalendarbookDbMonitor != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 177
 178                 r = pCalendarbookDbMonitor->Construct();
 179                 SysTryReturn(NID_SCL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 180
 181
 182         }
 183
 184         r = __mutex.Acquire();
 185         SysTryReturn(NID_SCL, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
 186
 187         if (pCalendarbookDbMonitor != null)
 188         {
 189                 __pCalendarbookDbMonitor = pCalendarbookDbMonitor.release();
 190         }
 191
 192         __refCnt++;
 193
 194         r = __mutex.Release();
 195         SysTryReturn(NID_SCL, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
 196
 197         return __pCalendarbookDbMonitor;
 198 }
 199
 200 void
 201 _CalendarbookDbMonitor::Release(void)
 202 {
 203         result r = __mutex.Acquire();
 204         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
 205
 206         __refCnt--;
 207
 208         if (__refCnt == 0)
 209         {
 210                 delete __pCalendarbookDbMonitor;
 211                 __pCalendarbookDbMonitor = null;
 212         }
 213
 214         r = __mutex.Release();
 215         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
 216 }
 217
 218 void
 219 _CalendarbookDbMonitor::OnCalendarbookDbChanged(const char* pViewUri, void* pUserData)
 220 {
 221         _CalendarbookDbMonitor* pCalendarbookDbMonitor = static_cast<_CalendarbookDbMonitor*>(pUserData);
 222         _CalendarbookDbChangeEvent* pEvent = pCalendarbookDbMonitor->__pEvent.get();
 223
 224         _CalendarbookDbChangeType changeType;
 225         if (strcmp(pViewUri, _calendar_event._uri) == 0)
 226         {
 227                 changeType = _CALENDARBOOK_DB_CHANGE_TYPE_EVENT;
 228         }
 229         else if (strcmp(pViewUri, _calendar_todo._uri) == 0)
 230         {
 231                 changeType = _CALENDARBOOK_DB_CHANGE_TYPE_TODO;
 232         }
 233         else
 234         {
 235                 return;
 236         }
 237
 238         std::unique_ptr<_CalendarbookDbChangeEventArg> pArg(new (std::nothrow) _CalendarbookDbChangeEventArg(changeType));
 239         SysTryReturnVoidResult(NID_SCL, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 240
 241         result r = pEvent->Fire(*pArg.get());
 242         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 243
 244         pArg.release();
 245 }
 246
 247 void
 248 _CalendarbookDbMonitor::InitCalendarbookDbMonitor(void)
 249 {
 250         result r = __mutex.Create();
 251         SysTryReturnVoidResult(NID_SCL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has been occurred.");
 252 }
 253
 254 }}  // Tizen::Social