2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
4 // Licensed under the Apache License, Version 2.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
8 // http://www.apache.org/licenses/LICENSE-2.0
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
18 * @file FSys_PowerManagerImpl.cpp
19 * @brief This is the implementation file for _PowerManagerImpl class.
22 #include <unique_ptr.h>
27 #include <runtime_info.h>
30 #include <FAppIActiveAppEventListener.h>
31 #include <FBaseSysLog.h>
32 #include <FBaseColArrayListT.h>
33 #include <FBaseColIMapEnumerator.h>
34 #include <FSysIBatteryEventListener.h>
35 #include <FSysIChargingEventListener.h>
36 #include <FSysIScreenEventListener.h>
37 #include <FSysIBootEventListener.h>
38 #include <FSys_IPowerManagerEventListener.h>
40 #include <FApp_AppImpl.h>
41 #include <FApp_AppInfo.h>
42 #include <FApp_AppManagerImpl.h>
43 #include <FBase_NativeError.h>
44 #include <FIo_AppServiceIpcMessages.h>
45 #include <FIo_IpcClient.h>
46 #include <FSys_Types.h>
47 #include <FSys_BatteryImpl.h>
48 #include <FSys_DeviceManagerImpl.h>
49 #include <FSys_PowerManagerImpl.h>
53 using namespace Tizen::App;
54 using namespace Tizen::Base;
55 using namespace Tizen::Base::Collection;
56 using namespace Tizen::Io;
58 namespace Tizen { namespace System
61 static const int _DEVICE_CPU = 1;
62 static const int _DEVICE_POWER_LEVEL_ON = 1;
63 static const int _DEVICE_POWER_LEVEL_OFF = 0;
64 static const int _APPID_LENGTH = 10;
65 static const int _DEACTIVATED_BRIGHTNESS_CONTROL = -1;
66 static const float _BRIGHTNESS_RESOLUTION = 10.0;
68 #ifndef VCONFKEY_SERVICE_READY
69 #define VCONFKEY_SERVICE_READY "memory/appservice/serviceready"
72 bool _activeApp = false;
73 bool _deviceCpuPowerOn = false;
74 bool _keepCpuAwake = false;
75 bool _keepScreenOnState = false;
77 IBatteryEventListener* pIBatteryEventListener = null;
79 ArrayListT<IScreenEventListener*>* __pSceenEventList = null;
80 ArrayListT<IChargingEventListener*>* __pChargingEventList = null;
81 ArrayListT<_IPowerManagerEventListener*> __powerEventList;
82 ArrayListT<IBootEventListener*>* __pBootEventList = null;
84 bool _PowerManagerImpl::_InitPowerManager = false;
87 class _ActiveEventListener
88 : public IActiveAppEventListener
91 virtual void OnActiveAppChanged(const Tizen::App::AppId& appId);
95 _ActiveEventListener::OnActiveAppChanged(const Tizen::App::AppId& appId)
98 SysLog(NID_SYS, "Active App is %ls.", appId.GetPointer());
100 if(appId == _AppInfo::GetApplicationId())
108 if (_keepScreenOnState == true) //In case of Screen power control, it has to be released automatically, when application goes deactive state.
110 ret = pm_unlock_state(LCD_NORMAL, GOTO_STATE_NOW);
111 SysTryReturnVoidResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the power state");
112 _keepScreenOnState = false;
115 if (_keepCpuAwake == true || _deviceCpuPowerOn == true) //In case of CPU power control, it has to be keep despite of deactive state.
117 ret = power_lock_state(POWER_STATE_SCREEN_OFF, 0);
118 SysTryReturnVoidResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the power state");
123 _ActiveEventListener* pActiveEventListener = null;
126 BatteryLevelVConfCallback(keynode_t* node, void* userData)
128 SysLog(NID_SYS, "Battery Warn Level is changed");
129 BatteryLevel batteryLevel;
131 if (strcmp(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, vconf_keynode_get_name(node)) == 0)
134 if(vconf_get_int(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, &level) >= 0)
138 case VCONFKEY_SYSMAN_BAT_LEVEL_EMPTY:
139 batteryLevel = BATTERY_EMPTY;
141 case VCONFKEY_SYSMAN_BAT_LEVEL_CRITICAL:
142 batteryLevel = BATTERY_CRITICAL;
144 case VCONFKEY_SYSMAN_BAT_LEVEL_LOW:
145 batteryLevel = BATTERY_LOW;
147 case VCONFKEY_SYSMAN_BAT_LEVEL_HIGH:
148 batteryLevel = BATTERY_HIGH;
150 case VCONFKEY_SYSMAN_BAT_LEVEL_FULL:
151 batteryLevel = BATTERY_FULL;
154 SysLogException(NID_SYS, E_SYSTEM, "Unavailable battery level is required.");
157 _AppImpl* pAppImpl = _AppImpl::GetInstance();
160 SysLog(NID_SYS, "Battery Level event is forwarded");
161 pAppImpl->OnBatteryLevelChanged(batteryLevel);
168 DeviceBatteryCallback(int percent, void* userData)
170 SysLog(NID_SYS, "Battery Level is called %d", percent);
172 if (pIBatteryEventListener != null)
174 pIBatteryEventListener->OnBatteryLevelChangedInPercentage(percent);
179 RuntimeInfoChangedCallback(runtime_info_key_e key, void* userData)
183 if(_AppInfo::GetAppState() == RUNNING)
185 if (__pChargingEventList != null)
187 bool charging = false;
188 ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, &charging);
191 for(int i = 0; i < __pChargingEventList->GetCount(); i++)
193 result r = E_SUCCESS;
194 IChargingEventListener* pIChargingEventListener = null;
196 r = __pChargingEventList->GetAt(i, pIChargingEventListener);
198 if (IsFailed(r) == false)
200 pIChargingEventListener->OnChargingStateChanged(charging);
210 PowerChangedCallback(power_state_e state, void* userData)
212 std::unique_ptr< IEnumeratorT<_IPowerManagerEventListener*> > pEnumerator(__powerEventList.GetEnumeratorN());
213 _IPowerManagerEventListener* pIPowerManagerEventListener = null;
215 if (__pSceenEventList != null)
217 if (state == POWER_STATE_SCREEN_OFF)
219 for (int i = 0; i < __pSceenEventList->GetCount(); i++)
221 IScreenEventListener* pIScreenEventListener = null;
222 result r = E_SUCCESS;
223 r = __pSceenEventList->GetAt(i, pIScreenEventListener);
224 if (IsFailed(r) == false)
226 pIScreenEventListener->OnScreenOff();
230 if(pEnumerator != null)
232 while(pEnumerator->MoveNext() == E_SUCCESS)
234 pEnumerator->GetCurrent(pIPowerManagerEventListener);
235 if(pIPowerManagerEventListener != null)
237 pIPowerManagerEventListener->OnScreenStateChanged(false);
242 else if(state == POWER_STATE_NORMAL)
244 for (int i = 0; i < __pSceenEventList->GetCount(); i++)
246 IScreenEventListener* pIScreenEventListener = null;
247 result r = E_SUCCESS;
248 r = __pSceenEventList->GetAt(i, pIScreenEventListener);
249 if (IsFailed(r) == false)
251 pIScreenEventListener->OnScreenOn();
255 if(pEnumerator != null)
257 while(pEnumerator->MoveNext() == E_SUCCESS)
259 pEnumerator->GetCurrent(pIPowerManagerEventListener);
260 if(pIPowerManagerEventListener != null)
262 pIPowerManagerEventListener->OnScreenStateChanged(true);
271 ScreenEventVConfCallback(keynode_t* node, void* userData)
274 int sysBrightness = 0;
276 if (__pSceenEventList == null)
278 SysLogException(NID_SYS, E_SYSTEM, "SceenEventList is not initialized.");
281 errorCode = vconf_get_int(VCONFKEY_PM_CURRENT_BRIGHTNESS, &sysBrightness);
285 SysLogException(NID_SYS, E_SYSTEM, "It failed to get Screen brightness");
289 for (int i = 0; i < __pSceenEventList->GetCount(); i++)
291 IScreenEventListener* pIScreenEventListener = null;
292 __pSceenEventList->GetAt(i, pIScreenEventListener);
293 if (pIScreenEventListener != null)
296 int maxBrightness = -1;
297 int ret = device_get_max_brightness(0, &maxBrightness);
300 SysLogException(NID_SYS, E_SYSTEM, "It failed to get the device max brightness");
303 sysBrightness = (sysBrightness == 0) ? 1 : sysBrightness;
304 brightness = (int)ceil(((_BRIGHTNESS_RESOLUTION / (float) maxBrightness)) * sysBrightness);
305 pIScreenEventListener->OnScreenBrightnessChanged(brightness);
310 _PowerManagerImpl::_PowerManagerImpl(void)
314 _PowerManagerImpl::~_PowerManagerImpl(void)
319 _PowerManagerImpl::Init()
321 if(_InitPowerManager == false)
323 __powerEventList.Construct();
324 pActiveEventListener = new (std::nothrow) _ActiveEventListener();
325 _AppManagerImpl* pAppManager = _AppManagerImpl::GetInstance();
326 pAppManager->AddActiveAppEventListener(*pActiveEventListener);
327 _InitPowerManager = true;
332 _PowerManagerImpl::Term()
334 if(_InitPowerManager == true)
336 _AppManagerImpl* pAppManager = _AppManagerImpl::GetInstance();
337 pAppManager->RemoveActiveAppEventListener(*pActiveEventListener);
338 delete(pActiveEventListener);
339 pActiveEventListener = null;
341 _InitPowerManager = false;
346 _PowerManagerImpl::IsActive(void)
349 result r = E_SUCCESS;
350 _AppManagerImpl* pAppManagerImpl = _AppManagerImpl::GetInstance();
352 if(pAppManagerImpl == null)
358 r = pAppManagerImpl->GetActiveApp(appId);
362 SysLog(NID_SYS, "current active is:%ls, required:%ls", appId.GetPointer(), _AppInfo::GetApplicationId().GetPointer());
363 if(appId == _AppInfo::GetApplicationId())
381 _PowerManagerImpl::KeepScreenOnState(bool keepOn, bool dimming)
384 unsigned int state = LCD_DIM;
385 _PowerManagerImpl::Init();
386 SysLog(NID_SYS, "Power control option: keep %d, dimming %d", keepOn, dimming);
388 if (keepOn == true && IsActive() == true)
398 ret = pm_lock_state(state, GOTO_STATE_NOW, 0);
399 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the screen state");
400 _keepScreenOnState = true;
404 ret = pm_unlock_state(LCD_NORMAL, GOTO_STATE_NOW);
405 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the screen state");
406 _keepScreenOnState = false;
409 SysLog(NID_SYS, "change screen power policy: keepOn(%d) and dimming(%d)", keepOn, dimming);
415 _PowerManagerImpl::KeepCpuAwake(bool enable)
418 _PowerManagerImpl::Init();
422 ret = power_lock_state(POWER_STATE_SCREEN_OFF, 0);
423 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the power state");
424 _keepCpuAwake = true;
428 if(_deviceCpuPowerOn == false)
430 ret = power_unlock_state(POWER_STATE_SCREEN_OFF);
431 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the power state");
433 _keepCpuAwake = false;
436 SysLog(NID_SYS, "change cpu power policy: keepAwake(%s)", enable ? "true" : "false");
441 _PowerManagerImpl::InitBatteryEvent(void)
443 int ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, BatteryLevelVConfCallback, null);
444 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to set the battery event");
450 _PowerManagerImpl::OnForeground(void)
456 _PowerManagerImpl::OnBackground(void)
462 _PowerManagerImpl::RestoreScreenBrightness(void)
464 result r = E_SUCCESS;
466 ArrayList requestMessage;
467 ArrayList responseMessage;
469 SysTryReturn(NID_SYS, IsActive() == true, E_SUCCESS, r, "It is not active app.");
471 unique_ptr<_IpcClient> pIpcClient (new (std::nothrow) _IpcClient());
472 SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
474 r = pIpcClient->Construct(_COMMUNICATION_DISPATCHER_IPC_ID);
475 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to create IpcClient", GetErrorMessage(r));
477 requestMessage.Construct();
478 responseMessage.Construct();
480 String serviceId = _SYSTEM_SERVICE_ID;
481 String commandId = _SYSTEM_COMMAND_RESTORE_BRIGHTNESS;
483 requestMessage.Add(serviceId);
484 requestMessage.Add(commandId);
486 unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
487 SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
489 r = pIpcClient->SendRequest(pMsg.get());
490 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to ipc message", GetErrorMessage(r));
492 String* pResult = (String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA);
494 SysTryReturnResult(NID_SYS, pResult != null, E_SYSTEM, "It is failed to receive Ipc response.");
495 SysTryReturnResult(NID_SYS, *pResult == _SYSTEM_RESULT_OK, E_SYSTEM, "It is failed to set brightness.");
497 responseMessage.RemoveAll(true);
502 _PowerManagerImpl::SetScreenBrightness(int brightness)
505 int maxBrightness = 0;
506 int actualBrightness = 0;
507 result r = E_SUCCESS;
509 SysTryReturn(NID_SYS, IsActive() == true, E_SUCCESS, r, "It is not active app.");
510 SysTryReturnResult(NID_SYS, (brightness > 0 && brightness < 11), E_OUT_OF_RANGE,
511 "[E_OUT_OF_RANGE] The specified brightness is out of range.");
513 SysLog(NID_SYS, "Set brightness (%d)", brightness);
515 ret = device_get_max_brightness(0, &maxBrightness);
516 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to get the device max brightness");
518 actualBrightness = maxBrightness * brightness / _BRIGHTNESS_RESOLUTION;
520 ArrayList requestMessage;
521 ArrayList responseMessage;
523 unique_ptr<_IpcClient> pIpcClient (new (std::nothrow) _IpcClient());
524 SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
526 r = pIpcClient->Construct(_COMMUNICATION_DISPATCHER_IPC_ID);
527 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to create IpcClient", GetErrorMessage(r));
529 requestMessage.Construct();
530 responseMessage.Construct();
532 String serviceId = _SYSTEM_SERVICE_ID;
533 String commandId = _SYSTEM_COMMAND_CHANGE_BRIGHTNESS;
534 String brightnessValue;
535 brightnessValue.Append(actualBrightness);
537 requestMessage.Add(serviceId);
538 requestMessage.Add(commandId);
539 requestMessage.Add(brightnessValue);
541 unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
542 SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
544 r = pIpcClient->SendRequest(pMsg.get());
545 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to ipc message", GetErrorMessage(r));
547 String* pResult = (String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA);
549 SysTryReturnResult(NID_SYS, pResult != null, E_SYSTEM, "It is failed to receive Ipc response.");
550 SysTryReturnResult(NID_SYS, *pResult == _SYSTEM_RESULT_OK, E_SYSTEM, "It is failed to set brightness.");
552 responseMessage.RemoveAll(true);
557 _PowerManagerImpl::GetScreenBrightness(void)
561 int maxBrightness = -1;
565 ret = device_get_brightness(0, &brightness);
568 SysLogException(NID_SYS, E_SYSTEM, "It failed to get the device brightness");
569 SetLastResult(E_SYSTEM);
570 return _DEACTIVATED_BRIGHTNESS_CONTROL;
578 SysLog(NID_SYS, "System Brightness is %d", brightness);
579 ret = device_get_max_brightness(0, &maxBrightness);
582 SysLogException(NID_SYS, E_SYSTEM, "It failed to get the device max brightness");
583 SetLastResult(E_SYSTEM);
584 return _DEACTIVATED_BRIGHTNESS_CONTROL;
586 return ceil(((_BRIGHTNESS_RESOLUTION / (float) maxBrightness)) * brightness);
590 _PowerManagerImpl::IsScreenOn(void)
592 power_state_e powerState = power_get_state();
594 if (powerState == POWER_STATE_SCREEN_OFF)
605 _PowerManagerImpl::TurnScreenOn(void)
607 result r = E_SUCCESS;
608 int ret = power_wakeup(true);
609 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to unlock the normal screen state");
610 ret = pm_change_state(LCD_NORMAL);
611 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to change to the normal screen state");
617 _PowerManagerImpl::TurnScreenOff(void)
619 result r = E_SUCCESS;
620 int ret = pm_change_state(LCD_OFF);
622 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to unlock the screen off screen state");
628 _PowerManagerImpl::SetScreenEventListener(IScreenEventListener& listener)
630 result r = E_SUCCESS;
632 r = AddScreenEventListener(listener, true);
636 SysLog(NID_SYS, "It failed to register ScreenEventListener");
639 SysLog(NID_SYS,"It successed to register ScreenEventListener");
644 _PowerManagerImpl::AddScreenEventListener(IScreenEventListener& listener, bool isSet)
646 result r = E_SUCCESS;
648 if (__pSceenEventList == null)
650 std::unique_ptr< ArrayListT<IScreenEventListener*> > pSceenEventList(new ArrayListT<IScreenEventListener*>);
651 SysTryReturnResult(NID_SYS, pSceenEventList, E_SYSTEM, "Memory allocation failed");
652 pSceenEventList->Construct();
654 errorCode = vconf_notify_key_changed(VCONFKEY_PM_CURRENT_BRIGHTNESS, ScreenEventVConfCallback, null);
655 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add ScreenEvent listener.");
657 errorCode = power_set_changed_cb(PowerChangedCallback, null);
658 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add ScreenEvent listener.");
659 __pSceenEventList = pSceenEventList.release();
660 SysLog(NID_SYS,"It successed to register power_set_changed_cb");
663 if (isSet == true && __pSceenEventList->GetCount() != 0)
665 r = __pSceenEventList->SetAt(&listener, 0);
669 r = __pSceenEventList->Add(&listener);
676 _PowerManagerImpl::RemoveScreenEventListener(IScreenEventListener& listener)
678 result r = E_SUCCESS;
680 SysTryReturnResult(NID_SYS,__pSceenEventList != null, E_OBJ_NOT_FOUND, "IScreenEventListener list is empty");
682 r = __pSceenEventList->Remove(&listener);
684 if (__pSceenEventList->GetCount() == 0)
686 delete __pSceenEventList;
687 __pSceenEventList = null;
694 _PowerManagerImpl::SetChargingEventListener(IChargingEventListener& listener)
696 result r = E_SUCCESS;
698 r = AddChargingEventListener(listener, true);
702 SysLog(NID_SYS, "It failed to register battery charging event");
709 _PowerManagerImpl::AddChargingEventListener(IChargingEventListener& listener, bool isSet)
711 result r = E_SUCCESS;
713 if (__pChargingEventList == null)
715 __pChargingEventList = new ArrayListT<IChargingEventListener*>;
716 SysTryReturnResult(NID_SYS, __pChargingEventList, E_SYSTEM, "Memory allocation failed");
717 __pChargingEventList->Construct();
719 errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, RuntimeInfoChangedCallback, null);
722 SysLog(NID_SYS, "It failed to register battery charging event");
723 delete __pChargingEventList;
724 __pChargingEventList = null;
729 if (isSet == false || __pChargingEventList->GetCount() == 0)
731 r = __pChargingEventList->Add(&listener);
735 r = __pChargingEventList->SetAt(&listener, 0);
742 _PowerManagerImpl::RemoveChargingEventListener(IChargingEventListener& listener)
744 result r = E_SUCCESS;
746 SysTryReturnResult(NID_SYS,__pChargingEventList != null, E_OBJ_NOT_FOUND, "__pChargingEventList list is empty");
748 r = __pChargingEventList->Remove(&listener);
750 if (__pChargingEventList->GetCount() == 0)
752 delete __pChargingEventList;
753 __pChargingEventList = null;
759 _PowerManagerImpl::SetBatteryEventListener(IBatteryEventListener* pListener)
763 if (pListener != null)
766 if(pIBatteryEventListener == null)
768 ret = device_battery_set_cb(DeviceBatteryCallback, null);
771 SysLog(NID_SYS, "It failed to register battery event");
774 pIBatteryEventListener = pListener;
778 pIBatteryEventListener = null;
779 ret = device_battery_unset_cb();
782 SysLog(NID_SYS, "It failed to unregister battery event");
790 _PowerManagerImpl::PowerControl(int deviceId, int level)
793 if(deviceId == _DEVICE_CPU)
795 if(level == _DEVICE_POWER_LEVEL_ON)
797 ret = power_lock_state(POWER_STATE_SCREEN_OFF, 0);
798 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the power state");
799 _deviceCpuPowerOn = true;
803 else if(level == _DEVICE_POWER_LEVEL_OFF)
805 if(_keepScreenOnState == false)
807 ret = power_unlock_state(POWER_STATE_SCREEN_OFF);
808 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the power state");
810 _deviceCpuPowerOn = false;
818 _PowerManagerImpl::GetCurrentBatteryLevelInPercentage(void)
821 int batteryLevel = 0;
823 ret = device_battery_get_percent(&batteryLevel);
826 SetLastResult(E_SYSTEM);
833 _PowerManagerImpl::GetCurrentBatteryLevel(void)
835 int batteryLevel = 0;
836 BatteryLevel level = BATTERY_EMPTY;
837 int ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, &batteryLevel);
840 SysLogException(NID_SYS, E_SYSTEM, "It is failed to get battery level.");
846 case VCONFKEY_SYSMAN_BAT_LEVEL_FULL:
847 level = BATTERY_LEVEL_FULL;
849 case VCONFKEY_SYSMAN_BAT_LEVEL_HIGH:
850 level = BATTERY_LEVEL_HIGH;
852 case VCONFKEY_SYSMAN_BAT_LEVEL_LOW:
853 level = BATTERY_LEVEL_LOW;
855 case VCONFKEY_SYSMAN_BAT_LEVEL_CRITICAL:
856 level = BATTERY_LEVEL_CRITICAL;
859 level = BATTERY_LEVEL_EMPTY;
867 _PowerManagerImpl::IsCharging(void)
869 bool chargeState = false;
871 ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, &chargeState);
874 SetLastResult(E_SYSTEM);
882 _PowerManagerImpl::Add_IPowerManagerEventListener(_IPowerManagerEventListener* listener)
884 _PowerManagerImpl::Init();
885 __powerEventList.Add(listener);
890 _PowerManagerImpl::Remove_IPowerManagerEventListener(_IPowerManagerEventListener* listener)
892 _PowerManagerImpl::Init();
893 __powerEventList.Remove(listener);
898 BootEventVconfCallback(keynode_t* node, void* userData)
900 if (__pBootEventList == null)
902 SysLogException(NID_SYS, E_SYSTEM, "BootEventList is not initialized.");
907 const int errorCode = vconf_get_int(VCONFKEY_SERVICE_READY, &bootReady);
911 SysLogException(NID_SYS, E_SYSTEM, "It failed to get Boot event status");
915 std::unique_ptr< IEnumeratorT<IBootEventListener*> > pEnum(__pBootEventList->GetEnumeratorN());
919 while (pEnum->MoveNext() == E_SUCCESS)
921 IBootEventListener* pListener = null;
922 pEnum->GetCurrent(pListener);
924 pListener->OnBootCompleted();
928 SysLog(NID_SYS, "Finished invoking boot complete event listener.");
932 _PowerManagerImpl::AddBootEventListener(IBootEventListener& listener)
934 if (__pBootEventList == null)
936 std::unique_ptr< ArrayListT<IBootEventListener*> > pBootEventList(new ArrayListT<IBootEventListener*>);
937 SysTryReturnResult(NID_SYS, pBootEventList, E_SYSTEM, "Memory allocation failed");
938 pBootEventList->Construct();
941 errorCode = vconf_notify_key_changed(VCONFKEY_SERVICE_READY, BootEventVconfCallback, null);
942 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add BootEvent listener.");
944 __pBootEventList = pBootEventList.release();
945 SysLog(NID_SYS, "It successed to register boot event listener.");
948 return __pBootEventList->Add(&listener);
952 _PowerManagerImpl::RemoveBootEventListener(IBootEventListener& listener)
954 result r = E_SUCCESS;
956 SysTryReturnResult(NID_SYS,__pBootEventList != null, E_OBJ_NOT_FOUND, "IBootEventListener list is empty");
958 r = __pBootEventList->Remove(&listener);
960 if (__pBootEventList->GetCount() == 0)
962 delete __pBootEventList;
963 __pBootEventList = null;
970 _PowerManagerImpl::GetInstance(PowerManager& powerManager)
972 return powerManager.__pPowerManagerImpl;
975 const _PowerManagerImpl*
976 _PowerManagerImpl::GetInstance(const PowerManager& powerManager)
978 return powerManager.__pPowerManagerImpl;