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();
}
* @brief This is the implementation for the _AppWidgetManagerProxy class.
*/
+#include <FBaseRt.h>
#include <FIo_IpcClient.h>
#include <FShell_AppWidgetManagerIpcMessage.h>
#include "FShell_AppWidgetProviderManagerImpl.h"
__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;
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();
}
};
+_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;
}
{
return E_SUCCESS;
}
- return __pLockManager->Unlock();
+
+ _LockManagerProxy* pLockManagerProxy = _LockManagerProxy::GetInstance();
+ SysTryReturnResult(NID_SHELL, pLockManagerProxy, E_SYSTEM, "Failed to _LockManagerProxy::GetInstance()!");
+
+ return pLockManagerProxy->Unlock();
}
#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)
{
{
}
+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.");
//
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
: 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