src/FScl_CalendarbookDbMonitor.cpp

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