From b825052914fde43ee1e53d6d98db853880f0aa6c Mon Sep 17 00:00:00 2001 From: "jungmin76.park" Date: Wed, 15 May 2013 09:56:12 +0900 Subject: [PATCH] apply dynamic singleton pattern to internal classes and add retry code to AppWidgetManagerProxy Change-Id: I982208432f446091aee77aa0caec8890ef8f75a2 Signed-off-by: jungmin76.park --- src/FShellAppWidgetProvider.cpp | 4 ++ src/FShell_AppWidgetManagerProxy.cpp | 20 +++++++++- src/core/FShellLockManager.cpp | 6 +++ src/core/FShell_LockManagerImpl.cpp | 70 ++++++++++++++++----------------- src/core/FShell_LockManagerProxy.cpp | 76 +++++++++++++++++++++++++++++++++--- src/inc/FShell_LockManagerImpl.h | 8 +++- src/inc/FShell_LockManagerProxy.h | 13 +++++- 7 files changed, 151 insertions(+), 46 deletions(-) diff --git a/src/FShellAppWidgetProvider.cpp b/src/FShellAppWidgetProvider.cpp index c7e1009..e41d840 100644 --- a/src/FShellAppWidgetProvider.cpp +++ b/src/FShellAppWidgetProvider.cpp @@ -60,12 +60,16 @@ AppWidgetProvider::GetId() const result AppWidgetProvider::SetAppWidgetFrame(AppWidgetFrame* pAppWidgetFrame) { + SysAssertf(__pAppWidgetProviderImpl != null, "Not yet constructed. The factory is called when AppWidgetProvider needs to be created. The SetAppWidgetProviderFactory() method should be called in App::OnAppInitializing(), to receive the event correctly. Implementing AppWidgetProviderFactory is mandatory to provide AppWidget functionality."); + return __pAppWidgetProviderImpl->SetAppWidgetFrame(pAppWidgetFrame); } AppWidgetFrame* AppWidgetProvider::GetAppWidgetFrame() { + SysAssertf(__pAppWidgetProviderImpl != null, "Not yet constructed. The factory is called when AppWidgetProvider needs to be created. The SetAppWidgetProviderFactory() method should be called in App::OnAppInitializing(), to receive the event correctly. Implementing AppWidgetProviderFactory is mandatory to provide AppWidget functionality."); + return __pAppWidgetProviderImpl->GetAppWidgetFrame(); } diff --git a/src/FShell_AppWidgetManagerProxy.cpp b/src/FShell_AppWidgetManagerProxy.cpp index fcfc1b7..61e90bc 100644 --- a/src/FShell_AppWidgetManagerProxy.cpp +++ b/src/FShell_AppWidgetManagerProxy.cpp @@ -19,6 +19,7 @@ * @brief This is the implementation for the _AppWidgetManagerProxy class. */ +#include #include #include #include "FShell_AppWidgetProviderManagerImpl.h" @@ -82,8 +83,23 @@ _AppWidgetManagerProxy::Construct(void) __pIpcClient = new (std::nothrow) _IpcClient(); SysTryReturnResult(NID_SHELL, __pIpcClient != null, E_OUT_OF_MEMORY, "_IpcClient creation failed."); - result r = __pIpcClient->Construct(IPC_SERVER_NAME, this); - SysTryReturn(NID_SHELL, !IsFailed(r), r, r, "_IpcClient constructing failed [%s].", GetErrorMessage(r)); + const int MAX_TRY_COUNT = 5; + const int TRY_SLEEP_TIME = 500; + + int count = 0; + while (true) + { + result r = __pIpcClient->Construct(IPC_SERVER_NAME, this); + if (r == E_SUCCESS) + { + SysLog(NID_APP, "Succeeded in connecting service(%s)", IPC_SERVER_NAME); + return E_SUCCESS; + } + + SysTryReturn(NID_APP, ++count < MAX_TRY_COUNT, E_SYSTEM, r, "[%s] Failed to connect service.(%s)", GetErrorMessage(r), IPC_SERVER_NAME); + + Tizen::Base::Runtime::Thread::Sleep(TRY_SLEEP_TIME); + } SysLog(NID_SHELL, "Exit."); return E_SUCCESS; diff --git a/src/core/FShellLockManager.cpp b/src/core/FShellLockManager.cpp index df4bd25..d161c4f 100644 --- a/src/core/FShellLockManager.cpp +++ b/src/core/FShellLockManager.cpp @@ -96,18 +96,24 @@ LockManager::Construct(void) bool LockManager::IsLocked(void) const { + SysAssertf(__pLockManagerImpl != null, "[E_SYSTEM] Not yet constructed."); + return __pLockManagerImpl->IsLocked(); } bool LockManager::IsSecureMode(void) const { + SysAssertf(__pLockManagerImpl != null, "[E_SYSTEM] Not yet constructed."); + return __pLockManagerImpl->IsSecureMode(); } result LockManager::Unlock(void) { + SysAssertf(__pLockManagerImpl != null, "[E_SYSTEM] Not yet constructed."); + return __pLockManagerImpl->Unlock(); } diff --git a/src/core/FShell_LockManagerImpl.cpp b/src/core/FShell_LockManagerImpl.cpp index fc0c490..01ccc07 100644 --- a/src/core/FShell_LockManagerImpl.cpp +++ b/src/core/FShell_LockManagerImpl.cpp @@ -52,59 +52,55 @@ enum }; +_LockManagerImpl* _LockManagerImpl::__pTheInstance = null; - -_LockManagerImpl::_LockManagerImpl() +_LockManagerImpl::_LockManagerImpl(void) { } -_LockManagerImpl::~_LockManagerImpl() +_LockManagerImpl::~_LockManagerImpl(void) { } -_LockManagerImpl* -_LockManagerImpl::GetInstance() +void +_LockManagerImpl::InitSingleton(void) { - static _LockManagerImpl* pLockManagerImpl = null; - if( pLockManagerImpl == null ) - { - pLockManagerImpl = new (std::nothrow) _LockManagerImpl(); - SysTryReturn(NID_APP, pLockManagerImpl, null, E_OUT_OF_MEMORY, "The memory is insufficient."); + std::unique_ptr<_LockManagerImpl> pInst(new (std::nothrow) _LockManagerImpl()); + SysTryReturnVoidResult(NID_SHELL, pInst, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY)); - result r = pLockManagerImpl->Construct(); - SysTryReturn(NID_APP, !IsFailed(r), null, r, "[%s] Propagating.", GetErrorMessage(r)); - } + result r = pInst->Construct(); + SysTryReturnVoidResult(NID_SHELL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r)); - return pLockManagerImpl; + __pTheInstance = pInst.release(); + std::atexit(DestroySingleton); } -result -_LockManagerImpl::Construct(void) +void +_LockManagerImpl::DestroySingleton(void) { - std::unique_ptr< _LockManagerProxy > pLockManagerProxy(new (std::nothrow) _LockManagerProxy); - SysTryReturnResult(NID_APP, pLockManagerProxy, E_OUT_OF_MEMORY, "The memory is insufficient."); - - const int MAX_TRY_COUNT = 5; - const int TRY_SLEEP_TIME = 250; + delete __pTheInstance; +} - int count = 0; - while (true) +_LockManagerImpl* +_LockManagerImpl::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + if (__pTheInstance == null) { - result r = pLockManagerProxy->Construct(); - if (r == E_SUCCESS) + ClearLastResult(); + pthread_once(&onceBlock, InitSingleton); + result r = GetLastResult(); + if (IsFailed(r)) { - SysLog(NID_APP, "Succeeded in connecting lock manager service."); - break; + onceBlock = PTHREAD_ONCE_INIT; } - - SysTryReturn(NID_APP, count < MAX_TRY_COUNT, E_SYSTEM, r, "[%s] Failed to connect lock manager service.", GetErrorMessage(r)); - - count++; - Tizen::Base::Runtime::Thread::Sleep(TRY_SLEEP_TIME); } + return __pTheInstance; +} - __pLockManager = pLockManagerProxy.release(); - +result +_LockManagerImpl::Construct(void) +{ return E_SUCCESS; } @@ -148,7 +144,11 @@ _LockManagerImpl::Unlock(void) { return E_SUCCESS; } - return __pLockManager->Unlock(); + + _LockManagerProxy* pLockManagerProxy = _LockManagerProxy::GetInstance(); + SysTryReturnResult(NID_SHELL, pLockManagerProxy, E_SYSTEM, "Failed to _LockManagerProxy::GetInstance()!"); + + return pLockManagerProxy->Unlock(); } diff --git a/src/core/FShell_LockManagerProxy.cpp b/src/core/FShell_LockManagerProxy.cpp index 20f1117..c4ea037 100644 --- a/src/core/FShell_LockManagerProxy.cpp +++ b/src/core/FShell_LockManagerProxy.cpp @@ -24,17 +24,26 @@ #include #include #include +#include #include #include "FShell_LockManagerIpcMessages.h" #include "FShell_LockManagerProxy.h" using namespace Tizen::Base; +using namespace Tizen::Io; using namespace Tizen::Shell; +namespace +{ +const char IPC_SERVER_NAME[] = "osp.shell.ipcserver.lockmanager"; +}; + namespace Tizen { namespace Shell { +_LockManagerProxy* _LockManagerProxy::__pTheInstance = null; + _LockManagerProxy::_LockManagerProxy(void) : __pIpcClient(null) { @@ -44,20 +53,75 @@ _LockManagerProxy::~_LockManagerProxy(void) { } +void +_LockManagerProxy::InitSingleton(void) +{ + std::unique_ptr<_LockManagerProxy> pInst(new (std::nothrow) _LockManagerProxy()); + SysTryReturnVoidResult(NID_SHELL, pInst, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY)); + + result r = pInst->Construct(); + SysTryReturnVoidResult(NID_SHELL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r)); + + __pTheInstance = pInst.release(); + std::atexit(DestroySingleton); +} + +void +_LockManagerProxy::DestroySingleton(void) +{ + delete __pTheInstance; +} + +_LockManagerProxy* +_LockManagerProxy::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + if (__pTheInstance == null) + { + ClearLastResult(); + pthread_once(&onceBlock, InitSingleton); + result r = GetLastResult(); + if (IsFailed(r)) + { + onceBlock = PTHREAD_ONCE_INIT; + } + } + return __pTheInstance; +} + result -_LockManagerProxy::Construct() +_LockManagerProxy::Construct(void) { - __pIpcClient = new (std::nothrow) Tizen::Io::_IpcClient(); - SysTryReturnResult(NID_APP, __pIpcClient != null, E_OUT_OF_MEMORY, "The memory is not sufficient."); + SysLog(NID_SHELL, "Enter."); + + __pIpcClient = new (std::nothrow) _IpcClient(); + SysTryReturnResult(NID_SHELL, __pIpcClient != null, E_OUT_OF_MEMORY, "_IpcClient creation failed."); + + const int MAX_TRY_COUNT = 5; + const int TRY_SLEEP_TIME = 250; + + int count = 0; + while (true) + { + result r = __pIpcClient->Construct(IPC_SERVER_NAME); + if (r == E_SUCCESS) + { + SysLog(NID_APP, "Succeeded in connecting service(%s)", IPC_SERVER_NAME); + return E_SUCCESS; + } + + SysTryReturn(NID_APP, count < MAX_TRY_COUNT, E_SYSTEM, r, "[%s] Failed to connect service.(%s)", GetErrorMessage(r), IPC_SERVER_NAME); - result r = __pIpcClient->Construct("osp.shell.ipcserver.lockmanager"); - SysTryReturnResult(NID_APP, !IsFailed(r), r, "_IpcClient constructing failed."); + count++; + Tizen::Base::Runtime::Thread::Sleep(TRY_SLEEP_TIME); + } + SysLog(NID_SHELL, "Exit."); return E_SUCCESS; } result -_LockManagerProxy::Unlock() +_LockManagerProxy::Unlock(void) { SysTryReturnResult(NID_APP, __pIpcClient != null, E_INVALID_STATE, "__pIpcClient instance must not be null."); diff --git a/src/inc/FShell_LockManagerImpl.h b/src/inc/FShell_LockManagerImpl.h index 2737735..409f183 100755 --- a/src/inc/FShell_LockManagerImpl.h +++ b/src/inc/FShell_LockManagerImpl.h @@ -135,8 +135,14 @@ private: // result Construct(void); + static void InitSingleton(void); + static void DestroySingleton(void); + private: - _LockManagerProxy* __pLockManager; + + static _LockManagerImpl* __pTheInstance; + friend struct std::default_delete< _LockManagerImpl >; + }; }} // Tizen::Shell diff --git a/src/inc/FShell_LockManagerProxy.h b/src/inc/FShell_LockManagerProxy.h index 93a5c5c..b89151a 100644 --- a/src/inc/FShell_LockManagerProxy.h +++ b/src/inc/FShell_LockManagerProxy.h @@ -38,21 +38,30 @@ class _LockManagerProxy : public Tizen::Base::Object { public: - _LockManagerProxy(void); - virtual ~_LockManagerProxy(void); + static _LockManagerProxy* GetInstance(void); result Construct(void); result Unlock(); private: + _LockManagerProxy(void); + + virtual ~_LockManagerProxy(void); + _LockManagerProxy(const _LockManagerProxy& rhs); _LockManagerProxy& operator =(const _LockManagerProxy& rhs); + static void InitSingleton(void); + static void DestroySingleton(void); + + private: + static _LockManagerProxy* __pTheInstance; Tizen::Io::_IpcClient* __pIpcClient; + friend struct std::default_delete< _LockManagerProxy >; }; // _LockManagerProxy } } // Tizen::Shell -- 2.7.4