From 3b3901b1211bcf19a98260aeee4736f0b1c12e37 Mon Sep 17 00:00:00 2001 From: Hokwon Song Date: Wed, 17 Jul 2013 15:53:14 +0900 Subject: [PATCH] Runtime move to common service Change-Id: I6dd18245df4540525c3dad4fac39acbbb319b330 Signed-off-by: Hokwon Song --- CMakeLists.txt | 3 + inc/CommonService.h | 2 + inc/FSys_RuntimeInfoStub.h | 79 ++++++++ inc/FSys_SystemServiceIpcEventForAsync.h | 56 ++++++ src/CommonService.cpp | 3 + src/FSys_SystemServiceIpcEventForAsync.cpp | 58 ++++++ src/runtime/FSys_RuntimeInfoStub.cpp | 304 +++++++++++++++++++++++++++++ 7 files changed, 505 insertions(+) create mode 100644 inc/FSys_RuntimeInfoStub.h create mode 100644 inc/FSys_SystemServiceIpcEventForAsync.h create mode 100644 src/FSys_SystemServiceIpcEventForAsync.cpp create mode 100644 src/runtime/FSys_RuntimeInfoStub.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 00a0a91..4e0ca8e 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,15 +23,18 @@ INCLUDE_DIRECTORIES ( /usr/include/osp/server /usr/include/chromium /usr/include/osp/system-service/inc + /usr/include/osp/system-server/ inc ) SET (${this_target}_SOURCE_FILES src/system/FSys_SettingService.cpp + src/runtime/FSys_RuntimeInfoStub.cpp src/FApp_PackageManagerStub.cpp src/FUi_UiManagerStub.cpp src/CommonService.cpp src/CommonServiceEntry.cpp + src/FSys_SystemServiceIpcEventForAsync.cpp ) #ADD_SUBDIRECTORY(src/system) diff --git a/inc/CommonService.h b/inc/CommonService.h index 3070b73..c606178 100644 --- a/inc/CommonService.h +++ b/inc/CommonService.h @@ -36,6 +36,7 @@ class _UiManagerStub; namespace Tizen { namespace System { class _SettingService; +class _RuntimeInfoStub; }} /** @@ -64,6 +65,7 @@ private: Tizen::App::_PackageManagerStub* __pPackageManagerStub; std::unique_ptr __pUiManagerStub; Tizen::System::_SettingService* __pSettingService; + Tizen::System::_RuntimeInfoStub* __pRuntimeInfoStub; }; #endif // _COMMON_SERVICE_H_ diff --git a/inc/FSys_RuntimeInfoStub.h b/inc/FSys_RuntimeInfoStub.h new file mode 100644 index 0000000..ff2b030 --- /dev/null +++ b/inc/FSys_RuntimeInfoStub.h @@ -0,0 +1,79 @@ +// +// Open Service Platform +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_RuntimeInfoStub.h + * @brief This is the header file of the _RuntimeInfoStub class. + * + * This header file contains the declarations of the _RuntimeInfoStub class. + */ + +#ifndef _FSYS_RUNTIME_INFO_STUB_H_ +#define _FSYS_RUNTIME_INFO_STUB_H_ + +#include +#include +#include +#include + +#include "FSys_SystemServiceIpcEventForAsync.h" + +namespace Tizen { namespace System +{ +class _OSP_EXPORT_ _RuntimeInfoStub + : public Tizen::Base::Object + , public Tizen::Io::_IIpcServerEventListener +{ +public: + static _RuntimeInfoStub* GetInstance(void); + virtual ~_RuntimeInfoStub(void); + +private: + static void InitSingleton(void); + static void DestroySingleton(void); + + _RuntimeInfoStub(void); + result Construct(void); + + bool OnRequestOccured(const Tizen::Base::Collection::ArrayList& request, Tizen::Base::Collection::ArrayList* response); + virtual void OnIpcRequestReceived(Tizen::Io::_IpcServer& server, const IPC::Message& message); + result SendDataAsync(const int pid, Tizen::Base::Collection::ArrayList* data); + + static void SendResponse(int pid, int msg_id, long long size, result rcode); + static void* GetDirectorySizeAsync(void* data); + + virtual void OnIpcServerStarted(const Tizen::Io::_IpcServer& server) {} + virtual void OnIpcServerStopped(const Tizen::Io::_IpcServer& server) {} + virtual void OnIpcClientConnected(const Tizen::Io::_IpcServer& server, int clientId) {} + virtual void OnIpcClientDisconnected(const Tizen::Io::_IpcServer&server, int clientId) {} + +private: + int __currentPid; + Tizen::Base::String __serviceId; + Tizen::Base::String __command; + Tizen::Base::String __result; + + std::unique_ptr< Tizen::Io::_IpcServer > __pIpcServer; + std::unique_ptr< _SystemServiceIpcEventForAsync > __pIpcEventForAsync; + + static _RuntimeInfoStub* __pRuntimeInfoStub; + Tizen::Base::Runtime::Mutex __Mutex; +}; // _RuntimeInfoStub + +}} // Tizen::System + +#endif // _FSYS_RUNTIME_INFO_STUB_H_ diff --git a/inc/FSys_SystemServiceIpcEventForAsync.h b/inc/FSys_SystemServiceIpcEventForAsync.h new file mode 100644 index 0000000..202a4b7 --- /dev/null +++ b/inc/FSys_SystemServiceIpcEventForAsync.h @@ -0,0 +1,56 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SystemServiceIpcEventForAsync.h + * @brief This is the header file for the %_SystemServiceIpcEventForAsync class. + * + * This header file contains the declarations of the %_SystemServiceIpcEventForAsync class. + */ + +#ifndef _FSYS_SYSTEM_SERVICE_EVENT_FOR_ASYNC_H_ +#define _FSYS_SYSTEM_SERVICE_EVENT_FOR_ASYNC_H_ + +#include +#include +#include + +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Io; + +namespace Tizen { namespace System { +class _OSP_EXPORT_ _SystemServiceIpcEventForAsync + : public Tizen::Base::Runtime::EventDrivenThread +{ +public: + _SystemServiceIpcEventForAsync(_IpcServer *pIpcServer); + + bool OnStart(void) + { + return true; + } + void OnStop(void) {} + result Construct(long stackSize, Tizen::Base::Runtime::ThreadPriority priority); + void OnUserEventReceivedN(RequestId requestId, IList *pArgs); +private: + _IpcServer* __pIpcServer; +}; +}} //Tizen::System + + +#endif // _FSYS_SYSTEM_SERVICE_EVENT_FOR_ASYNC_H_ + diff --git a/src/CommonService.cpp b/src/CommonService.cpp index 5909a38..17c256c 100644 --- a/src/CommonService.cpp +++ b/src/CommonService.cpp @@ -21,6 +21,7 @@ #include "FApp_PackageManagerStub.h" #include "FUi_UiManagerStub.h" #include "system/FSys_SettingService.h" +#include "FSys_RuntimeInfoStub.h" using namespace std; using namespace Tizen::App; @@ -31,6 +32,7 @@ using namespace Tizen::Ui; CommonService::CommonService(void) : __pPackageManagerStub(null) , __pSettingService(null) + , __pRuntimeInfoStub(null) { } @@ -98,5 +100,6 @@ CommonService::InitializeServices(void) __pUiManagerStub = move(pUiManagerStub); __pSettingService = _SettingService::GetInstance(); + __pRuntimeInfoStub = _RuntimeInfoStub::GetInstance(); } diff --git a/src/FSys_SystemServiceIpcEventForAsync.cpp b/src/FSys_SystemServiceIpcEventForAsync.cpp new file mode 100644 index 0000000..63e0050 --- /dev/null +++ b/src/FSys_SystemServiceIpcEventForAsync.cpp @@ -0,0 +1,58 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SystemServiceIpcEventForAsync.cpp + * @brief This is the header file for the %_SystemServiceIpcEventForAsync class. + * + * This header file contains the declarations of the %_SystemServiceIpcEventForAsync class. + */ + +#include +#include "FSys_SystemServiceIpcEventForAsync.h" + +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Base::Runtime; +using namespace Tizen::Io; + +namespace Tizen{ namespace System { + +_SystemServiceIpcEventForAsync::_SystemServiceIpcEventForAsync(_IpcServer *pIpcServer) +{ + __pIpcServer = pIpcServer; +} + +result +_SystemServiceIpcEventForAsync::Construct(long stackSize, ThreadPriority priority) +{ + return EventDrivenThread::Construct(stackSize, priority); +} + +void +_SystemServiceIpcEventForAsync::OnUserEventReceivedN(RequestId requestId, IList *pArgs) +{ + if(pArgs != null) + { + ArrayList* data = (ArrayList*)pArgs; + result r = __pIpcServer->SendResponse((int)requestId, new (std::nothrow) IoService_Data(*data)); + delete pArgs; + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, + "It is failed to send IPC message to %d. [%s]", (int)requestId, GetErrorMessage(r)); + } +} + +}} diff --git a/src/runtime/FSys_RuntimeInfoStub.cpp b/src/runtime/FSys_RuntimeInfoStub.cpp new file mode 100644 index 0000000..257e075 --- /dev/null +++ b/src/runtime/FSys_RuntimeInfoStub.cpp @@ -0,0 +1,304 @@ +// +// Open Service Platform +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_RuntimeInfoStub.cpp + * @brief This is the implementation for the _RuntimeInfoStub class. + */ +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "FSys_RuntimeInfo.h" +#include "FSys_RuntimeInfoStub.h" + +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Io; +using namespace Tizen::System; +using namespace Tizen::App; + +namespace { + static const wchar_t* RUNTIME_INFO_STUB_MUTEX_ID = L"osp.sys.ipcserver.runtimeinfo"; + static const int _RUNTIME_GET_PARAM_TYPE = 1; + static const wchar_t* _RUNTIME_SERVICE_ID = L"osp.sys.ipcserver.runtimeinfo"; + static const wchar_t* _RUNTIME_GET_SIZE = L"osp.system.command.runtime.get.size"; + static const wchar_t* _RUNTIME_RESULT_SUCCESS = L"osp.system.result.success"; + static const wchar_t* _RUNTIME_RESULT_SYSTEM = L"osp.system.result.system"; +} + +_RuntimeInfoStub* _RuntimeInfoStub::__pRuntimeInfoStub = null; + +static pthread_mutex_t send_msg_lock; +class _DirectorySizeObject +{ +public: + _DirectorySizeObject() + : path(null) + , pid(0) + , msg_id(0) + { + } + ~_DirectorySizeObject() + { + if(path != null) + { + delete [] path; + } + } + + char* path; + int pid; + int msg_id; +}; + +_RuntimeInfoStub::_RuntimeInfoStub(void) + : __pIpcServer(null) + , __pIpcEventForAsync(null) +{ + result r = E_SUCCESS; + r = __Mutex.Create(RUNTIME_INFO_STUB_MUTEX_ID); + SysTryReturn(NID_SYS, r == E_SUCCESS, , r, "It is failed to create mutex. [%s] Propaged.", GetErrorMessage(r)); + + if(pthread_mutex_init(&send_msg_lock, null)) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to init mutex."); + } +} + +_RuntimeInfoStub::~_RuntimeInfoStub(void) +{ + if (__pIpcServer) + { + __pIpcServer->Stop(); + } + + result r = __Mutex.Release(); + SysTryReturn(NID_SYS, r == E_SUCCESS, , r, "It is failed to release mutex. [%s] Propaged.", GetErrorMessage(r)); + + if(pthread_mutex_destroy(&send_msg_lock)) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to term mutex."); + } +} + +_RuntimeInfoStub* +_RuntimeInfoStub::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + + if (__pRuntimeInfoStub == null) + { + pthread_once(&onceBlock, InitSingleton); + } + return __pRuntimeInfoStub; +} + +void +_RuntimeInfoStub::InitSingleton(void) +{ + std::unique_ptr< _RuntimeInfoStub > pRuntimeInfoStub(new (std::nothrow) _RuntimeInfoStub()); + SysTryReturn(NID_SYS, pRuntimeInfoStub, , E_OUT_OF_MEMORY, "It is not enough memory."); + + result r = pRuntimeInfoStub->Construct(); + SysTryReturn(NID_SYS, !IsFailed(r), , r, "[%s] It is failed to get RuntimeInfoCommunicationStub.", GetErrorMessage(r)); + __pRuntimeInfoStub = pRuntimeInfoStub.release(); + atexit(DestroySingleton); +} + +void +_RuntimeInfoStub::DestroySingleton(void) +{ + delete __pRuntimeInfoStub; +} + +result +_RuntimeInfoStub::Construct(void) +{ + std::unique_ptr<_IpcServer> pIpcServer(new (std::nothrow) _IpcServer()); + SysTryReturnResult(NID_SYS, pIpcServer, E_OUT_OF_MEMORY, "Memory is insufficient."); + + result r = pIpcServer->Construct(String(_RUNTIME_SERVICE_ID), *this, true); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, "It is failed to construct."); + + r = pIpcServer->Start(); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, "It is failed to start."); + + __pIpcServer = move(pIpcServer); + return E_SUCCESS; +} + +void +_RuntimeInfoStub::OnIpcRequestReceived(_IpcServer& server, const IPC::Message& message) +{ + __currentPid = server.GetClientId(); + IPC_BEGIN_MESSAGE_MAP(_RuntimeInfoStub, message) + IPC_MESSAGE_HANDLER_EX(IoService_Request, &server, OnRequestOccured) + IPC_END_MESSAGE_MAP_EX() +} + +bool +_RuntimeInfoStub::OnRequestOccured(const ArrayList& request, ArrayList* response) +{ + bool isSuccess = false; + result r = E_SUCCESS; + + __serviceId = _RUNTIME_SERVICE_ID; + __command = *((String*)request.GetAt(_RUNTIME_GET_PARAM_TYPE)); + __result = L""; + + if(__command == _RUNTIME_GET_SIZE) + { + int mid = 0; + String* path = (String*)request.GetAt(_RUNTIME_GET_PARAM_TYPE+1); + String* messageId = (String*)request.GetAt(_RUNTIME_GET_PARAM_TYPE+2); + SysTryCatch(NID_SYS, path != null, r = E_SYSTEM, E_SYSTEM, "There is no path information."); + + std::unique_ptr< char > directoryPath(_StringConverter::CopyToCharArrayN(*path)); + Integer::Parse(*messageId, mid); + _DirectorySizeObject* dso = new (std::nothrow) _DirectorySizeObject(); + dso->pid = __currentPid; + dso->path = directoryPath.release(); + dso->msg_id = mid; + + pthread_t p_thread; + int thr_id = pthread_create(&p_thread, null, _RuntimeInfoStub::GetDirectorySizeAsync, dso); + if(thr_id < 0) + { + __result = _RUNTIME_RESULT_SYSTEM; + } + else + { + pthread_detach(p_thread); + __result = _RUNTIME_RESULT_SUCCESS; + } + } + else + { + __result = _RUNTIME_RESULT_SYSTEM; + } + + isSuccess = true; +CATCH: + response->Add(__serviceId); + response->Add(__command); + if (isSuccess == true) + { + response->Add(__result); + } + + ArrayList* temp = const_cast(&request); + temp->RemoveAll(true); + return isSuccess; +} + +void* +_RuntimeInfoStub::GetDirectorySizeAsync(void* data) +{ + result r= E_SUCCESS; + long long size = 0; + + _DirectorySizeObject* dso = (_DirectorySizeObject*) data; + SysTryCatch(NID_SYS, dso != null, r = E_SYSTEM, r, "There is no _DirectorySizeObject."); + size = _RuntimeInfo::GetDirectorySize(dso->path); + +CATCH: + _RuntimeInfoStub::SendResponse(dso->pid, dso->msg_id, size, r); + delete dso; + return null; +} + +void +_RuntimeInfoStub::SendResponse(int pid, int msg_id, long long size, result rcode) +{ + result r = E_SUCCESS; + pthread_mutex_lock(&send_msg_lock); + + ArrayList* data = null; + String* pValue = null; + String* pMessageId = null; + + SysLog(NID_SYS, "It sends asynchronous result to pid [%d].", pid); + + data = new (std::nothrow) ArrayList(SingleObjectDeleter); + data->Construct(); + + pMessageId = new (std::nothrow) String(); + pMessageId->Append(msg_id); + + data->Add(new (std::nothrow) String(_RUNTIME_SERVICE_ID)); + data->Add(new (std::nothrow) String(_RUNTIME_GET_SIZE)); + data->Add(pMessageId); + + pValue = new (std::nothrow) String(); + pValue->Append(size); + data->Add(pValue); + + if(rcode == E_SUCCESS) + { + data->Add(new (std::nothrow) String(_RUNTIME_RESULT_SUCCESS)); + } + else + { + data->Add(new (std::nothrow) String(_RUNTIME_RESULT_SYSTEM)); + } + + _RuntimeInfoStub* pRuntimeInfoStub = null; + pRuntimeInfoStub = _RuntimeInfoStub::GetInstance(); + SysTryReturn(NID_SYS, pRuntimeInfoStub, , E_SYSTEM, "RuntimeInfoStub is not created."); + + pRuntimeInfoStub->SendDataAsync(pid, data); +CATCH: + pthread_mutex_unlock(&send_msg_lock); + +} + +result +_RuntimeInfoStub::SendDataAsync(const int pid, Tizen::Base::Collection::ArrayList* data) +{ + __Mutex.Acquire(); + result r = E_SUCCESS; + + SysTryCatch(NID_SYS, __pIpcServer != null, r = E_SYSTEM, E_SYSTEM, "IPC server is not ready."); + SysTryCatch(NID_SYS, data != null, r = E_SYSTEM, E_SYSTEM, "There is no data."); + + if(__pIpcEventForAsync == null) + { + __pIpcEventForAsync.reset(new (std::nothrow) _SystemServiceIpcEventForAsync(__pIpcServer.get())); + SysTryCatch(NID_SYS, __pIpcEventForAsync != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "It is not enough memory."); + __pIpcEventForAsync->Construct(1048576, Tizen::Base::Runtime::THREAD_PRIORITY_MID); + __pIpcEventForAsync->Start(); + } + + r = __pIpcEventForAsync->SendUserEvent((RequestId)pid, (IList*)data); + SysTryCatch(NID_SYS, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Message is failed to add on event thread."); + +CATCH: + if(r != E_SUCCESS) + { + delete data; + } + __Mutex.Release(); + return r; +} -- 2.7.4