apply dynamic singleton pattern to internal classes and add retry code to AppWidgetMa...

Change-Id: I982208432f446091aee77aa0caec8890ef8f75a2
Signed-off-by: jungmin76.park <jungmin76.park@samsung.com>

diff --git a/src/FShellAppWidgetProvider.cpp b/src/FShellAppWidgetProvider.cpp
index c7e1009..e41d840 100644 (file)
--- 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 (file)
--- a/src/FShell_AppWidgetManagerProxy.cpp
+++ b/src/FShell_AppWidgetManagerProxy.cpp
@@ -19,6 +19,7 @@
  * @brief      This is the implementation for the _AppWidgetManagerProxy class.
  */
 
+#include <FBaseRt.h>
 #include <FIo_IpcClient.h>
 #include <FShell_AppWidgetManagerIpcMessage.h>
 #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 (file)
--- 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 (file)
--- 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 (file)
--- a/src/core/FShell_LockManagerProxy.cpp
+++ b/src/core/FShell_LockManagerProxy.cpp
@@ -24,17 +24,26 @@
 #include <unique_ptr.h>
 #include <FBaseErrors.h>
 #include <FBaseSysLog.h>
+#include <FBaseRt.h>
 #include <FIo_IpcClient.h>
 
 #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 (executable)
--- 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 (file)
--- 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