From 8d8b7685232c7921ec22e8070bdb71b307050644 Mon Sep 17 00:00:00 2001 From: Hokwon Song Date: Thu, 25 Jul 2013 12:20:06 +0900 Subject: [PATCH] Update PowerManager [dep:osp-common-service, osp-appfw, osp-appservice] Change-Id: Ibbcf47098d2526e5f5e98bd9c4b3c4a703bd705c Signed-off-by: Hokwon Song --- inc/CommonService.h | 2 + inc/FSys_PowerManagerStub.h | 85 ++++++++++++ src/CommonService.cpp | 3 + src/system/CMakeLists.txt | 1 + src/system/FSys_PowerManagerStub.cpp | 242 +++++++++++++++++++++++++++++++++++ 5 files changed, 333 insertions(+) create mode 100644 inc/FSys_PowerManagerStub.h create mode 100644 src/system/FSys_PowerManagerStub.cpp diff --git a/inc/CommonService.h b/inc/CommonService.h index 3933815..e3f2f6d 100644 --- a/inc/CommonService.h +++ b/inc/CommonService.h @@ -38,6 +38,7 @@ namespace Tizen { namespace System class _SettingService; class _RuntimeInfoStub; class _DeviceManagerStub; +class _PowerManagerStub; }} /** @@ -68,6 +69,7 @@ private: Tizen::System::_SettingService* __pSettingService; Tizen::System::_RuntimeInfoStub* __pRuntimeInfoStub; Tizen::System::_DeviceManagerStub* __pDeviceManagerStub; + Tizen::System::_PowerManagerStub* __pPowerManagerStub; }; #endif // _COMMON_SERVICE_H_ diff --git a/inc/FSys_PowerManagerStub.h b/inc/FSys_PowerManagerStub.h new file mode 100644 index 0000000..d515854 --- /dev/null +++ b/inc/FSys_PowerManagerStub.h @@ -0,0 +1,85 @@ +// +// 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_PowerManagerStub.h + * @brief This is the header file of the _PowerManagerStub class. + * + * This header file contains the declarations of the _PowerManagerStub class. + */ + +#ifndef _FSYS_POWER_MANAGER_STUB_H_ +#define _FSYS_POWER_MANAGER_STUB_H_ + +#include +#include +#include +#include +#include +#include "FApp_IAppEventListener.h" + +namespace Tizen { namespace System +{ +class _OSP_EXPORT_ _PowerManagerStub + : public Tizen::Base::Object + , public Tizen::Io::_IIpcServerEventListener + , public Tizen::App::_IAppEventListener + , public Tizen::App::IActiveAppEventListener +{ +public: + static _PowerManagerStub* GetInstance(void); + virtual ~_PowerManagerStub(void); + virtual void OnActiveAppChanged(const Tizen::App::AppId& appId); + +private: + static void InitSingleton(void); + static void DestroySingleton(void); + + _PowerManagerStub(void); + result Construct(void); + + result ChangeBrightness(void); + + _PowerManagerStub(const _PowerManagerStub& rhs); + _PowerManagerStub& operator =(const _PowerManagerStub& rhs); + + bool OnRequestOccured(const Tizen::Base::Collection::ArrayList& request, Tizen::Base::Collection::ArrayList* response); + + 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) {} + virtual void OnIpcRequestReceived(Tizen::Io::_IpcServer& server, const IPC::Message& message); + + virtual void OnApplicationLaunched(const Tizen::App::AppId& appId, int pid) {} + virtual void OnApplicationTerminated(const Tizen::App::AppId& appId, int pid); + +private: + std::unique_ptr __pIpcServer; + static _PowerManagerStub* __pPowerManagerStub; + Tizen::Base::Runtime::Mutex __Mutex; + Tizen::App::AppId __activeAppId; + Tizen::App::AppId __currentAppId; + Tizen::Base::Collection::HashMap __appBrightnessList; + Tizen::Base::String __serviceId; + Tizen::Base::String __command; + Tizen::Base::String __result; +}; // _PowerManagerStub + +}} // Tizen::System + +#endif // _FSYS_POWER_MANAGER_STUB_H_ diff --git a/src/CommonService.cpp b/src/CommonService.cpp index c4aa585..c9f0062 100644 --- a/src/CommonService.cpp +++ b/src/CommonService.cpp @@ -24,6 +24,7 @@ #include "system/FSys_SettingService.h" #include "FSys_RuntimeInfoStub.h" #include "FSys_DeviceManagerStub.h" +#include "FSys_PowerManagerStub.h" using namespace std; using namespace Tizen::App; @@ -36,6 +37,7 @@ CommonService::CommonService(void) , __pSettingService(null) , __pRuntimeInfoStub(null) , __pDeviceManagerStub(null) + , __pPowerManagerStub(null) { } @@ -109,5 +111,6 @@ CommonService::InitializeServices(void) { __pDeviceManagerStub = _DeviceManagerStub::GetInstance(); } + __pPowerManagerStub = _PowerManagerStub::GetInstance(); } diff --git a/src/system/CMakeLists.txt b/src/system/CMakeLists.txt index eb416f4..5d0ae74 100644 --- a/src/system/CMakeLists.txt +++ b/src/system/CMakeLists.txt @@ -11,6 +11,7 @@ SET (${this_target}_SOURCE_FILES FSys_SettingService.cpp FSys_RuntimeInfoStub.cpp FSys_DeviceManagerStub.cpp + FSys_PowerManagerStub.cpp FSys_SystemServiceIpcEventForAsync.cpp ) diff --git a/src/system/FSys_PowerManagerStub.cpp b/src/system/FSys_PowerManagerStub.cpp new file mode 100644 index 0000000..dcc162a --- /dev/null +++ b/src/system/FSys_PowerManagerStub.cpp @@ -0,0 +1,242 @@ +// +// 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_PowerManagerStub.cpp + * @brief This is the implementation for the _PowerManagerStub class. + */ +#include +#include +#include +#include + +#include "FApp_AppManagerImpl.h" +#include "FSys_PowerManagerStub.h" +#include "FSys_PowerManager.h" + +using namespace std; +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* POWER_MANAGER_SERVICE_ID = L"osp.sys.ipcserver.powermanager"; + static const wchar_t* POWER_MANAGER_SERVICE_MUTEX_ID = L"osp.sys.ipcserver.devicemanager"; + static const wchar_t* _POWER_BRIGHTNESS_CHANGE = L"osp.system.command.power.change.brightness"; + static const wchar_t* _POWER_BRIGHTNESS_RESTORE = L"osp.system.command.power.restore.brightness"; + static const int _POWER_COMMAND_ID = 1; + static const wchar_t* _POWER_OK = L"osp.system.result.ok"; + static const wchar_t* _POWER_ERROR = L"osp.system.result.error"; +} + +_PowerManagerStub* _PowerManagerStub::__pPowerManagerStub = null; + +_PowerManagerStub::_PowerManagerStub(void) + : __pIpcServer(null) + , __serviceId(POWER_MANAGER_SERVICE_ID) +{ + result r = __appBrightnessList.Construct(); + SysTryReturn(NID_SYS, r == E_SUCCESS, , r, "It is failed to initiate power manager app list."); +} + +_PowerManagerStub::~_PowerManagerStub(void) +{ + if (__pIpcServer) + { + __pIpcServer->Stop(); + } + + __appBrightnessList.RemoveAll(); +} + +_PowerManagerStub* +_PowerManagerStub::GetInstance() +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + + if (__pPowerManagerStub == null) + { + pthread_once(&onceBlock, InitSingleton); + } + return __pPowerManagerStub; +} + +void +_PowerManagerStub::InitSingleton(void) +{ + std::unique_ptr< _PowerManagerStub > pPowerManagerStub(new (std::nothrow) _PowerManagerStub()); + SysTryReturn(NID_SYS, pPowerManagerStub, ,E_OUT_OF_MEMORY, "It is not enough memory."); + result r = pPowerManagerStub->Construct(); + SysTryReturn(NID_SYS, !IsFailed(r), , r, "[%s] It is failed to get PowerManagerCommunicationStub.", GetErrorMessage(r)); + __pPowerManagerStub = pPowerManagerStub.release(); + atexit(DestroySingleton); +} + + +void +_PowerManagerStub::DestroySingleton(void) +{ + delete __pPowerManagerStub; +} + +result +_PowerManagerStub::Construct(void) +{ + unique_ptr<_IpcServer> pIpcServer(new (std::nothrow) _IpcServer()); + SysTryReturnResult(NID_SYS, pIpcServer, E_OUT_OF_MEMORY, "Memory is insufficient."); + + result r = pIpcServer->Construct(String(POWER_MANAGER_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."); + + _AppManagerImpl* pAppManagerImpl = null; + pAppManagerImpl = _AppManagerImpl::GetInstance(); + SysTryReturn(NID_SYS, pAppManagerImpl != null, E_SYSTEM , E_SYSTEM, "It is failed to get _AppManagerImpl class."); + + r = pAppManagerImpl->AddActiveAppEventListener(*this); + SysTryReturn(NID_SYS, r == E_SUCCESS || r == E_OBJ_ALREADY_EXIST, E_SYSTEM, E_SYSTEM, "[%s] It is failed to add active app event listener",GetErrorMessage(r)); + + r = pAppManagerImpl->AddAppEventListener(*this); + SysTryReturn(NID_SYS, r == E_SUCCESS || r == E_OBJ_ALREADY_EXIST, E_SYSTEM, E_SYSTEM, "It is failed to add app event listener"); + + __pIpcServer = move(pIpcServer); + + return E_SUCCESS; +} + +result +_PowerManagerStub::ChangeBrightness() +{ + result r = E_FAILURE; + + if(__appBrightnessList.GetCount() > 0) + { + Integer* brightness = (Integer*)__appBrightnessList.GetValue(__activeAppId); + + if(brightness != null) + { + r = _PowerManager::ChangeBrightness(brightness->ToInt()); + SysLog(NID_SYS, "change brightness %d", brightness->ToInt()); + } + } + if (IsFailed(r)) + { + r = _PowerManager::ChangeBrightness(0); + SysLog(NID_SYS, "change brightness system value."); + } + + return r; +} +void +_PowerManagerStub::OnIpcRequestReceived(_IpcServer& server, const IPC::Message& message) +{ + __currentAppId = server.GetClientPackageId(); + IPC_BEGIN_MESSAGE_MAP(_PowerManagerStub, message) + IPC_MESSAGE_HANDLER_EX(IoService_Request, &server, OnRequestOccured) + IPC_END_MESSAGE_MAP_EX() +} + +bool +_PowerManagerStub::OnRequestOccured(const ArrayList& request, ArrayList* response) +{ + bool isSuccess = false; + result r = E_SUCCESS; + + __command = *((String*)request.GetAt(_POWER_COMMAND_ID)); + + if (__command == _POWER_BRIGHTNESS_CHANGE) + { + SysTryCatch(NID_SYS, __activeAppId == __currentAppId, r = E_SUCCESS, r, + "It is not active application[%ls]. Current Active App is [%ls].", __currentAppId.GetPointer(), __activeAppId.GetPointer()); + int brightness = 0; + String* brightnessBuffer = (String*)request.GetAt(_POWER_COMMAND_ID + 1); + Integer::Parse(*brightnessBuffer, brightness); + + __appBrightnessList.Remove(__currentAppId, true); + + unique_ptr pBrightness(new (std::nothrow) Integer(brightness)); + unique_ptr pAppId(new (std::nothrow) String(__currentAppId)); + + r = __appBrightnessList.Add(*pAppId, *pBrightness); + SysTryCatch(NID_SYS, r == E_SUCCESS, r = E_SYSTEM, r, + "It is failed to add requested App Id(%ls) and Brightness(%d) on the managed app list.", pAppId->GetPointer(), pBrightness->ToInt()); + pAppId.release(); + pBrightness.release(); + r = ChangeBrightness(); + } + else if(__command == _POWER_BRIGHTNESS_RESTORE) + { + SysLog(NID_SYS, "Request bright restore"); + __appBrightnessList.Remove(__currentAppId, true); + r = ChangeBrightness(); + } + else + { + SysLogException(NID_SYS, E_SYSTEM, "Required Command[%ls] is not proccess on _PowerManager.", __command.GetPointer()); + r = E_SYSTEM; + } + + isSuccess = true; +CATCH: + if(r == E_SUCCESS) + { + __result = _POWER_OK; + } + else + { + __result = _POWER_ERROR; + } + + response->Add(__serviceId); + response->Add(__command); + response->Add(__result); + + ArrayList* temp = const_cast(&request); + temp->RemoveAll(true); + return isSuccess; +} + +void +_PowerManagerStub::OnApplicationTerminated(const AppId& appId, int pid) +{ + SysLog(NID_SYS, "Terminated app [%ls]", appId.GetPointer()); + String requiredAppId; + appId.SubString(0, 10, requiredAppId); + __appBrightnessList.Remove(requiredAppId, true); + ChangeBrightness(); +} + +void +_PowerManagerStub::OnActiveAppChanged(const AppId& appId) +{ + AppId smallAppId; + appId.SubString(0, 10, smallAppId); + SysLog(NID_SYS, "Active app [%ls]", appId.GetPointer()); + if(__activeAppId != smallAppId) + { + __activeAppId = smallAppId; + ChangeBrightness(); + } + else + { + SysLog(NID_SYS, "Current App[%ls] is already actived.", __activeAppId.GetPointer()); + } +} -- 2.7.4