src/base/runtime/FBaseRt_Event.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 /**
  18  * @file        FBaseRt_Event.cpp
  19  * @brief       This is the implementation file for the _Event class.
  20  *
  21  */
  22
  23 #include <new>
  24
  25 #include <FBaseColIEnumeratorT.h>
  26
  27 #include <FBaseSysLog.h>
  28 #include "FBaseRt_Event.h"
  29 #include "FBaseRt_EventManager.h"
  30 #include "FBaseRt_ThreadImpl.h"
  31
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Base::Collection;
  34 using namespace Tizen::Base::Runtime;
  35
  36 namespace Tizen { namespace Base { namespace Runtime
  37 {
  38
  39 _Event::_ListenerInfo&
  40 _Event::_ListenerInfo::operator =(const _ListenerInfo& rhs)
  41 {
  42         if (this != &rhs)
  43         {
  44                 pListener = rhs.pListener;
  45                 listener = rhs.listener;
  46                 eventManager = rhs.eventManager;
  47         }
  48
  49         return *this;
  50 }
  51
  52 bool
  53 _Event::_ListenerInfo::operator ==(const _ListenerInfo& rhs) const
  54 {
  55         if (listener == rhs.listener && eventManager == rhs.eventManager)
  56         {
  57                 return true;
  58         }
  59
  60         return false;
  61 }
  62
  63 bool
  64 _Event::_ListenerInfo::operator !=(const _ListenerInfo& rhs) const
  65 {
  66         if (listener != rhs.listener || eventManager != rhs.eventManager)
  67         {
  68                 return true;
  69         }
  70
  71         return false;
  72 }
  73
  74 _Event::_RefCount::_RefCount(void)
  75         : __count(1)
  76         , __destroyed(false)
  77 {
  78
  79 }
  80
  81 _Event::_RefCount::~_RefCount(void)
  82 {
  83
  84 }
  85
  86 int
  87 _Event::_RefCount::AddRef(void)
  88 {
  89         __count++;
  90         return __count;
  91 }
  92
  93 int
  94 _Event::_RefCount::Release(void)
  95 {
  96         __count--;
  97         if (__count == 0)
  98         {
  99                 delete this;
 100                 return 0;
 101         }
 102
 103         return __count;
 104 }
 105
 106 _Event::_Event(void)
 107 {
 108         __pRefCount = new (std::nothrow) _RefCount();
 109
 110         __handle = _EventManager::GetEventObjectManager().Register(*this);
 111 }
 112
 113 _Event::~_Event(void)
 114 {
 115         __pRefCount->__destroyed = true;
 116         __pRefCount->Release();
 117
 118         if (__handle.IsValid())
 119         {
 120                 _EventManager::GetEventObjectManager().Unregister(__handle);
 121         }
 122 }
 123
 124 result
 125 _Event::AddListener(const IEventListener& listener, bool calledByCallerThread)
 126 {
 127         result r = E_SUCCESS;
 128         bool exist = false;
 129         _ListenerInfo listenerInfo;
 130         _HandleT< _EventManager > eventManager;
 131
 132         if (calledByCallerThread)
 133         {
 134                 _ThreadImpl* pThreadImpl = _ThreadImpl::GetCurrentThreadImpl();
 135                 SysTryReturnResult(NID_BASE_RT, pThreadImpl != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] This is not OSP thread.");
 136
 137                 ThreadType threadType = pThreadImpl->GetThreadType();
 138                 SysTryReturnResult(NID_BASE_RT, threadType != THREAD_TYPE_WORKER, E_INVALID_OPERATION, "The caller thread is not an event driven thread.");
 139
 140                 ClearLastResult();
 141                 _EventManager* pEventManager = _EventManager::GetCurrentEventManager();
 142                 r = GetLastResult();
 143                 if (IsFailed(r))
 144                 {
 145                         SysPropagate(NID_BASE_RT, r);
 146                         return r;
 147                 }
 148
 149                 eventManager = pEventManager->GetHandle();
 150         }
 151
 152         IEnumeratorT< _ListenerInfo >* pEnum = __listeners.GetEnumeratorN();
 153         SysTryReturnResult(NID_BASE_RT, pEnum != null, E_OUT_OF_MEMORY, "Not enough memory.");
 154
 155         while (pEnum->MoveNext() == E_SUCCESS)
 156         {
 157                 pEnum->GetCurrent(listenerInfo);
 158
 159                 if (&listener == listenerInfo.pListener)
 160                 {
 161                         exist = true;
 162                         break;
 163                 }
 164         }
 165
 166         delete pEnum;
 167
 168         SysTryReturnResult(NID_BASE_RT, !exist, E_OBJ_ALREADY_EXIST, "[E_OBJ_ALREADY_EXIST] Listener already exist.");
 169
 170         listenerInfo.pListener = &listener;
 171         listenerInfo.listener = _EventManager::GetEventListenerObjectManager().Register(listener);
 172         listenerInfo.eventManager = eventManager;
 173
 174         r = __listeners.Add(listenerInfo);
 175         SysTryReturn(NID_BASE_RT, !IsFailed(r), r, r, "[%s] Propagating.", GetErrorMessage(r));
 176
 177         return E_SUCCESS;
 178 }
 179
 180 result
 181 _Event::RemoveListener(const IEventListener& listener)
 182 {
 183         result r = E_SUCCESS;
 184         bool exist = false;
 185         _ListenerInfo listenerInfo;
 186
 187         IEnumeratorT< _ListenerInfo >* pEnum = __listeners.GetEnumeratorN();
 188         SysTryReturnResult(NID_BASE_RT, pEnum != null, E_OUT_OF_MEMORY, "Not enough memory.");
 189
 190         while (pEnum->MoveNext() == E_SUCCESS)
 191         {
 192                 pEnum->GetCurrent(listenerInfo);
 193
 194                 if (listenerInfo.pListener == &listener)
 195                 {
 196                         r = __listeners.Remove(listenerInfo);
 197                         SysTryLog(NID_BASE_RT, !IsFailed(r), "[%s] Propagating.", GetErrorMessage(r));
 198
 199                         _EventManager::GetEventListenerObjectManager().Unregister(listenerInfo.listener);
 200
 201                         exist = true;
 202                         break;
 203                 }
 204         }
 205
 206         delete pEnum;
 207
 208         SysTryReturnResult(NID_BASE_RT, exist, E_OBJ_NOT_FOUND, "Listener not found.");
 209
 210         return E_SUCCESS;
 211 }
 212
 213 result
 214 _Event::Initialize(void)
 215 {
 216         result r = E_SUCCESS;
 217
 218         _EventManager* pEventManager = _EventManager::GetCurrentEventManager();
 219         SysTryReturnResult(NID_BASE_RT, pEventManager != null, E_INVALID_OPERATION, "Event manager does not exist.");
 220
 221         r = pEventManager->RegisterEvent(this->GetHandle());
 222         SysTryReturn(NID_BASE_RT, !IsFailed(r), r, r, "[%s] Failed to register an event.", GetErrorMessage(r));
 223
 224         __eventManager = pEventManager->GetHandle();
 225
 226         return E_SUCCESS;
 227 }
 228
 229 result
 230 _Event::FireAsync(IEventArg& arg)
 231 {
 232         SysTryReturnResult(NID_BASE_RT, __eventManager.IsValid(), E_INVALID_STATE, "Event manager is invalid state.");
 233
 234         _EventManager* pEventManager = _EventManager::GetEventManagerByHandle(__eventManager);
 235         SysTryReturnResult(NID_BASE_RT, pEventManager != null, E_INVALID_STATE, "Event manager is invalid state.");
 236
 237         pEventManager->FireEventAsync(__handle, std::tr1::shared_ptr< IEventArg >(&arg));
 238
 239         return E_SUCCESS;
 240 }
 241
 242 result
 243 _Event::Fire(IEventArg& arg)
 244 {
 245         std::tr1::shared_ptr< IEventArg > sharedArg(&arg);
 246
 247         return Fire(sharedArg);
 248 }
 249
 250 result
 251 _Event::Fire(std::tr1::shared_ptr< IEventArg > arg)
 252 {
 253         _RefCount* pRefCount = __pRefCount;
 254
 255         pRefCount->AddRef();
 256
 257         ProcessListeners(arg);
 258
 259         pRefCount->Release();
 260
 261         return E_SUCCESS;
 262 }
 263
 264 result
 265 _Event::ProcessListeners(std::tr1::shared_ptr< IEventArg > arg)
 266 {
 267         _RefCount* pRefCount = __pRefCount;
 268
 269         _ListenerInfo listenerInfo;
 270         _EventManager* pEventManager = null;
 271         IEventListener* pEventListener = null;
 272
 273         IEnumeratorT< _ListenerInfo >* pEnum = __listeners.GetEnumeratorN();
 274         SysTryReturnResult(NID_BASE_RT, pEnum != null, E_OUT_OF_MEMORY, "Not enough memory.");
 275
 276         while (pEnum->MoveNext() == E_SUCCESS)
 277         {
 278                 pEnum->GetCurrent(listenerInfo);
 279
 280                 if (listenerInfo.eventManager.IsValid())
 281                 {
 282                         pEventManager = _EventManager::GetEventManagerByHandle(listenerInfo.eventManager);
 283                         if (pEventManager == null)
 284                         {
 285                                 continue;
 286                         }
 287
 288                         _EventManager* pCurrentEventManager = _EventManager::GetCurrentEventManager();
 289                         if (pCurrentEventManager != null)
 290                         {
 291                                 if (pEventManager->GetHandle() != pCurrentEventManager->GetHandle())
 292                                 {
 293                                         pEventManager->CallListenerAsync(this->GetHandle(), arg, listenerInfo.listener);
 294                                         continue;
 295                                 }
 296                         }
 297                         else
 298                         {
 299                                 pEventManager->CallListenerAsync(this->GetHandle(), arg, listenerInfo.listener);
 300                                 continue;
 301
 302                         }
 303                 }
 304
 305                 pEventListener = _EventManager::GetEventListenerObjectManager().GetObject(listenerInfo.listener);
 306                 if (pEventListener != null)
 307                 {
 308                         FireImpl(*pEventListener, *arg);
 309                         if (pRefCount->__destroyed)
 310                         {
 311                                 break;
 312                         }
 313                 }
 314         }
 315
 316         delete pEnum;
 317         return E_SUCCESS;
 318 }
 319
 320 int
 321 _Event::GetListenerCount(void)
 322 {
 323         return __listeners.GetCount();
 324 }
 325
 326 const _HandleT< _Event >
 327 _Event::GetHandle(void) const
 328 {
 329         return __handle;
 330 }
 331
 332 _HandleT< _Event >
 333 _Event::GetHandle(void)
 334 {
 335         return __handle;
 336 }
 337
 338 void
 339 _Event::FireImpl(IEventListener& listener, const IEventArg& arg)
 340 {
 341
 342 }
 343 } } } // Tizen::Base::Runtime