src/system/FSys_PowerManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FSys_PowerManagerImpl.cpp
  20  * @brief               This is the implementation file for _PowerManagerImpl class.
  21  */
  22
  23 #include <unique_ptr.h>
  24
  25 #include <pmapi.h>
  26 #include <power.h>
  27 #include <device.h>
  28 #include <runtime_info.h>
  29 #include <vconf.h>
  30
  31 #include <FAppIActiveAppEventListener.h>
  32 #include <FBaseSysLog.h>
  33 #include <FBaseColArrayListT.h>
  34 #include <FBaseColIMapEnumerator.h>
  35 #include <FSysIBatteryEventListener.h>
  36 #include <FSysIChargingEventListener.h>
  37 #include <FSysIScreenEventListener.h>
  38 #include <FSysIBootEventListener.h>
  39 #include <FSys_IPowerManagerEventListener.h>
  40
  41 #include <FApp_AppImpl.h>
  42 #include <FApp_AppInfo.h>
  43 #include <FApp_AppManagerImpl.h>
  44 #include <FBase_NativeError.h>
  45 #include <FIo_AppServiceIpcMessages.h>
  46 #include <FIo_IpcClient.h>
  47 #include <FSys_Types.h>
  48 #include <FSys_BatteryImpl.h>
  49 #include <FSys_DeviceManagerImpl.h>
  50 #include <FSys_PowerManagerImpl.h>
  51
  52 using namespace std;
  53
  54 using namespace Tizen::App;
  55 using namespace Tizen::Base;
  56 using namespace Tizen::Base::Collection;
  57 using namespace Tizen::Io;
  58
  59 namespace Tizen { namespace System
  60 {
  61
  62 static const int _DEVICE_CPU = 1;
  63 static const int _DEVICE_POWER_LEVEL_ON = 1;
  64 static const int _DEVICE_POWER_LEVEL_OFF = 0;
  65 static const int _APPID_LENGTH = 10;
  66 static const int _DEACTIVATED_BRIGHTNESS_CONTROL = -1;
  67 static const float _BRIGHTNESS_RESOLUTION = 10.0;
  68
  69 #ifndef VCONFKEY_SERVICE_READY
  70 #define VCONFKEY_SERVICE_READY  "memory/appservice/serviceready"
  71 #endif
  72
  73 bool _activeApp = false;
  74 bool _deviceCpuPowerOn = false;
  75 bool _keepCpuAwake = false;
  76 bool _keepScreenOnState = false;
  77
  78 IBatteryEventListener* pIBatteryEventListener = null;
  79
  80 ArrayListT<IScreenEventListener*>*      __pSceenEventList = null;
  81 ArrayListT<IChargingEventListener*>*    __pChargingEventList = null;
  82 ArrayListT<_IPowerManagerEventListener*>        __powerEventList;
  83 ArrayListT<IBootEventListener*>*        __pBootEventList = null;
  84
  85 bool _PowerManagerImpl::_InitPowerManager = false;
  86
  87
  88 class _ActiveEventListener
  89         : public IActiveAppEventListener
  90 {
  91 public:
  92         virtual void OnActiveAppChanged(const Tizen::App::AppId& appId);
  93 };
  94
  95 void
  96 _ActiveEventListener::OnActiveAppChanged(const Tizen::App::AppId& appId)
  97 {
  98         int ret = 0;
  99         if(appId == _AppInfo::GetApplicationId())
 100         {
 101                 _activeApp = true;
 102         }
 103         else
 104         {
 105                 _activeApp = false;
 106
 107                 if (_keepScreenOnState == true) //In case of Screen power control, it has to be released automatically, when application goes deactive state.
 108                 {
 109                         ret = pm_unlock_state(LCD_NORMAL, GOTO_STATE_NOW);
 110                         SysTryReturnVoidResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the power state");
 111                         _keepScreenOnState = false;
 112                 }
 113
 114                 if (_keepCpuAwake == true || _deviceCpuPowerOn == true) //In case of CPU power control, it has to be keep despite of deactive state.
 115                 {
 116                         ret = power_lock_state(POWER_STATE_SCREEN_OFF, 0);
 117                         SysTryReturnVoidResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the power state");
 118                 }
 119         }
 120 }
 121
 122  _ActiveEventListener* pActiveEventListener = null;
 123
 124 void
 125 DeviceBatteryWarnCallback(device_battery_warn_e status, void* userData)
 126 {
 127         SysLog(NID_SYS, "Battery Warn Level is called %d", status);
 128         BatteryLevel    batteryLevel;
 129
 130         switch(status)
 131         {
 132         case DEVICE_BATTERY_WARN_EMPTY:
 133         {
 134                 batteryLevel = BATTERY_EMPTY;
 135                 break;
 136         }
 137         case DEVICE_BATTERY_WARN_CRITICAL:
 138         {
 139                 batteryLevel = BATTERY_CRITICAL;
 140                 break;
 141         }
 142         case DEVICE_BATTERY_WARN_LOW:
 143         {
 144                 batteryLevel = BATTERY_LOW;
 145                 break;
 146         }
 147         case DEVICE_BATTERY_WARN_NORMAL:
 148         {
 149                 batteryLevel = BATTERY_HIGH;
 150                 break;
 151         }
 152         case DEVICE_BATTERY_WARN_FULL:
 153         {
 154                 batteryLevel = BATTERY_FULL;
 155                 break;
 156         }
 157         default:
 158                 return;
 159         }
 160         _AppImpl* pAppImpl = _AppImpl::GetInstance();
 161         if(pAppImpl != null)
 162         {
 163                 SysLog(NID_SYS, "Battery Level event is forwarded");
 164                 pAppImpl->OnBatteryLevelChanged(batteryLevel);
 165         }
 166
 167 }
 168
 169 void
 170 DeviceBatteryCallback(int percent, void* userData)
 171 {
 172         SysLog(NID_SYS, "Battery Level is called %d", percent);
 173
 174         if (pIBatteryEventListener != null)
 175         {
 176                 pIBatteryEventListener->OnBatteryLevelChangedInPercentage(percent);
 177         }
 178 }
 179
 180 void
 181 RuntimeInfoChangedCallback(runtime_info_key_e key, void* userData)
 182 {
 183         int ret = 0;
 184
 185         if(_AppInfo::GetAppState() == RUNNING)
 186         {
 187                 if (__pChargingEventList != null)
 188                 {
 189                         bool charging = false;
 190                         ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, &charging);
 191                         if (ret == 0)
 192                         {
 193                                 for(int i = 0; i < __pChargingEventList->GetCount(); i++)
 194                                 {
 195                                         result r = E_SUCCESS;
 196                                         IChargingEventListener* pIChargingEventListener = null;
 197
 198                                         r = __pChargingEventList->GetAt(i, pIChargingEventListener);
 199
 200                                         if (IsFailed(r) == false)
 201                                         {
 202                                                 pIChargingEventListener->OnChargingStateChanged(charging);
 203                                         }
 204                                 }
 205
 206                         }
 207                 }
 208         }
 209 }
 210
 211 void
 212 PowerChangedCallback(power_state_e state, void* userData)
 213 {
 214         std::unique_ptr< IEnumeratorT<_IPowerManagerEventListener*> > pEnumerator(__powerEventList.GetEnumeratorN());
 215         _IPowerManagerEventListener* pIPowerManagerEventListener = null;
 216
 217         if (__pSceenEventList != null)
 218         {
 219                 if (state == POWER_STATE_SCREEN_OFF)
 220                 {
 221                         for (int i = 0; i < __pSceenEventList->GetCount(); i++)
 222                         {
 223                                 IScreenEventListener* pIScreenEventListener = null;
 224                                 result r = E_SUCCESS;
 225                                 r = __pSceenEventList->GetAt(i, pIScreenEventListener);
 226                                 if (IsFailed(r) == false)
 227                                 {
 228                                         pIScreenEventListener->OnScreenOff();
 229                                 }
 230                         }
 231
 232                         if(pEnumerator != null)
 233                         {
 234                                 while(pEnumerator->MoveNext() == E_SUCCESS)
 235                                 {
 236
 237                                         pEnumerator->GetCurrent(pIPowerManagerEventListener);
 238                                         if(pIPowerManagerEventListener != null)
 239                                         {
 240                                                 pIPowerManagerEventListener->OnScreenStateChanged(false);
 241                                         }
 242                                 }
 243                         }
 244                 }
 245                 else
 246                 {
 247                          for (int i = 0; i < __pSceenEventList->GetCount(); i++)
 248                         {
 249                                 IScreenEventListener* pIScreenEventListener = null;
 250                                 result r = E_SUCCESS;
 251                                 r = __pSceenEventList->GetAt(i, pIScreenEventListener);
 252                                 if (IsFailed(r) == false)
 253                                 {
 254                                         pIScreenEventListener->OnScreenOn();
 255                                 }
 256                         }
 257
 258                         if(pEnumerator != null)
 259                         {
 260                                 while(pEnumerator->MoveNext() == E_SUCCESS)
 261                                 {
 262                                         pEnumerator->GetCurrent(pIPowerManagerEventListener);
 263                                         if(pIPowerManagerEventListener != null)
 264                                         {
 265                                                 pIPowerManagerEventListener->OnScreenStateChanged(true);
 266                                         }
 267                                 }
 268                         }
 269                 }
 270         }
 271 }
 272
 273 void
 274 ScreenEventVConfCallback(keynode_t* node, void* userData)
 275 {
 276         int errorCode = 0;
 277         int sysBrightness = 0;
 278
 279         if (__pSceenEventList == null)
 280         {
 281                 SysLogException(NID_SYS, E_SYSTEM, "SceenEventList is not initialized.");
 282                 return;
 283         }
 284         errorCode = vconf_get_int(VCONFKEY_PM_CURRENT_BRIGHTNESS, &sysBrightness);
 285
 286         if ( errorCode != 0)
 287         {
 288                 SysLogException(NID_SYS, E_SYSTEM, "It failed to get Screen brightness");
 289                 return;
 290         }
 291
 292         for (int i = 0; i < __pSceenEventList->GetCount(); i++)
 293         {
 294                 IScreenEventListener* pIScreenEventListener = null;
 295                 __pSceenEventList->GetAt(i, pIScreenEventListener);
 296                 if (pIScreenEventListener != null)
 297                 {
 298                         int brightness = -1;
 299                         int maxBrightness = -1;
 300                         int ret = device_get_max_brightness(0, &maxBrightness);
 301                         if (ret != 0)
 302                         {
 303                                 SysLogException(NID_SYS, E_SYSTEM, "It failed to get the device max brightness");
 304                                 maxBrightness = 100;
 305                         }
 306                         brightness = (int)ceil(((_BRIGHTNESS_RESOLUTION / (float) maxBrightness)) * sysBrightness);
 307                         pIScreenEventListener->OnScreenBrightnessChanged(brightness);
 308                 }
 309         }
 310 }
 311
 312 _PowerManagerImpl::_PowerManagerImpl(void)
 313 {
 314 }
 315
 316 _PowerManagerImpl::~_PowerManagerImpl(void)
 317 {
 318 }
 319
 320 void
 321 _PowerManagerImpl::Init()
 322 {
 323         if(_InitPowerManager == false)
 324         {
 325                 __powerEventList.Construct();
 326                 _InitPowerManager = true;
 327         }
 328 }
 329
 330 void
 331 _PowerManagerImpl::Term()
 332 {
 333         if(_InitPowerManager == true)
 334         {
 335                 _InitPowerManager = false;
 336         }
 337 }
 338
 339 bool
 340 _PowerManagerImpl::IsActive(void)
 341 {
 342         AppId appId;
 343         result r = E_SUCCESS;
 344         _AppManagerImpl* pAppManagerImpl = _AppManagerImpl::GetInstance();
 345
 346         if(pAppManagerImpl == null)
 347         {
 348                 _activeApp = false;
 349         }
 350         else
 351         {
 352                 r = pAppManagerImpl->GetActiveApp(appId);
 353
 354                 if(r == E_SUCCESS)
 355                 {
 356                         if(appId == _AppInfo::GetApplicationId())
 357                         {
 358                                 _activeApp = true;
 359                         }
 360                         else
 361                         {
 362                                 _activeApp = false;
 363                         }
 364                 }
 365                 else
 366                 {
 367                         _activeApp = false;
 368                 }
 369         }
 370         return _activeApp;
 371 }
 372
 373 result
 374 _PowerManagerImpl::KeepScreenOnState(bool keepOn, bool dimming)
 375 {
 376         int ret = -1;
 377         unsigned int state = LCD_DIM;
 378
 379         if (keepOn == true && IsActive() == true)
 380         {
 381                 if (dimming)
 382                 {
 383                         state = LCD_DIM;
 384                 }
 385                 else
 386                 {
 387                         state = LCD_NORMAL;
 388                 }
 389                 ret = pm_lock_state(state, GOTO_STATE_NOW, 0);
 390                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the screen state");
 391                 _keepScreenOnState = true;
 392         }
 393         else
 394         {
 395                 ret = pm_unlock_state(LCD_NORMAL, GOTO_STATE_NOW);
 396                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the screen state");
 397                 _keepScreenOnState = false;
 398         }
 399
 400         SysLog(NID_SYS, "change screen power policy: keepOn(%d) and dimming(%d)", keepOn, dimming);
 401
 402         return E_SUCCESS;
 403 }
 404
 405 result
 406 _PowerManagerImpl::KeepCpuAwake(bool enable)
 407 {
 408         int ret = 0;
 409         if (enable)
 410         {
 411                 ret = power_lock_state(POWER_STATE_SCREEN_OFF, 0);
 412                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the power state");
 413                 _keepCpuAwake = true;
 414         }
 415         else
 416         {
 417                  if(_deviceCpuPowerOn == false)
 418                 {
 419                         ret = power_unlock_state(POWER_STATE_SCREEN_OFF);
 420                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the power state");
 421                 }
 422                 _keepCpuAwake = false;
 423         }
 424
 425         SysLog(NID_SYS, "change cpu power policy: keepAwake(%s)", enable ? "true" : "false");
 426         return E_SUCCESS;
 427 }
 428
 429 result
 430 _PowerManagerImpl::InitBatteryEvent(void)
 431 {
 432         int ret = 0;
 433         ret = device_battery_warning_set_cb(DeviceBatteryWarnCallback, null);
 434
 435         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to set the battery event");
 436
 437         return E_SUCCESS;
 438 }
 439
 440 result
 441 _PowerManagerImpl::OnForeground(void)
 442 {
 443         return E_SUCCESS;
 444 }
 445
 446 result
 447 _PowerManagerImpl::OnBackground(void)
 448 {
 449         return E_SUCCESS;
 450 }
 451
 452 result
 453 _PowerManagerImpl::RestoreScreenBrightness(void)
 454 {
 455         result r = E_SUCCESS;
 456
 457         ArrayList requestMessage;
 458         ArrayList responseMessage;
 459
 460         SysTryReturn(NID_SYS, IsActive() == true, E_SUCCESS, r, "It is not active app.");
 461
 462         unique_ptr<_IpcClient> pIpcClient (new (std::nothrow) _IpcClient());
 463         SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
 464
 465         r = pIpcClient->Construct(_COMMUNICATION_DISPATCHER_IPC_ID);
 466         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to create IpcClient", GetErrorMessage(r));
 467
 468         requestMessage.Construct();
 469         responseMessage.Construct();
 470
 471         String serviceId = _SYSTEM_SERVICE_ID;
 472         String commandId = _SYSTEM_COMMAND_RESTORE_BRIGHTNESS;
 473
 474         requestMessage.Add(serviceId);
 475         requestMessage.Add(commandId);
 476
 477         unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
 478         SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
 479
 480         r = pIpcClient->SendRequest(pMsg.get());
 481         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to ipc message", GetErrorMessage(r));
 482
 483         unique_ptr<String> pResult((String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA));
 484
 485         SysTryReturnResult(NID_SYS, pResult != null, E_SYSTEM, "It is failed to receive Ipc response.");
 486         SysTryReturnResult(NID_SYS, *pResult == _SYSTEM_RESULT_OK, E_SYSTEM, "It is failed to set brightness.");
 487
 488         return E_SUCCESS;
 489 }
 490
 491 result
 492 _PowerManagerImpl::SetScreenBrightness(int brightness)
 493 {
 494         int ret = 0;
 495         int maxBrightness = 0;
 496         int actualBrightness = 0;
 497         result r = E_SUCCESS;
 498
 499         SysTryReturn(NID_SYS, IsActive() == true, E_SUCCESS, r, "It is not active app.");
 500         SysTryReturnResult(NID_SYS, (brightness > 0 && brightness < 11), E_OUT_OF_RANGE,
 501                                           "[E_OUT_OF_RANGE] The specified brightness is out of range.");
 502
 503         SysLog(NID_SYS, "Set brightness (%d)", brightness);
 504
 505         ret = device_get_max_brightness(0, &maxBrightness);
 506         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to get the device max brightness");
 507
 508         actualBrightness = maxBrightness * brightness / _BRIGHTNESS_RESOLUTION;
 509
 510         ArrayList requestMessage;
 511         ArrayList responseMessage;
 512
 513         unique_ptr<_IpcClient> pIpcClient (new (std::nothrow) _IpcClient());
 514         SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
 515
 516         r = pIpcClient->Construct(_COMMUNICATION_DISPATCHER_IPC_ID);
 517         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to create IpcClient", GetErrorMessage(r));
 518
 519         requestMessage.Construct();
 520         responseMessage.Construct();
 521
 522         String serviceId = _SYSTEM_SERVICE_ID;
 523         String commandId = _SYSTEM_COMMAND_CHANGE_BRIGHTNESS;
 524         String brightnessValue;
 525         brightnessValue.Append(actualBrightness);
 526
 527         requestMessage.Add(serviceId);
 528         requestMessage.Add(commandId);
 529         requestMessage.Add(brightnessValue);
 530
 531         unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
 532         SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
 533
 534         r = pIpcClient->SendRequest(pMsg.get());
 535         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to ipc message", GetErrorMessage(r));
 536
 537         unique_ptr<String> pResult((String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA));
 538
 539         SysTryReturnResult(NID_SYS, pResult != null, E_SYSTEM, "It is failed to receive Ipc response.");
 540         SysTryReturnResult(NID_SYS, *pResult == _SYSTEM_RESULT_OK, E_SYSTEM, "It is failed to set brightness.");
 541
 542         return E_SUCCESS;
 543 }
 544
 545 int
 546 _PowerManagerImpl::GetScreenBrightness(void)
 547 {
 548         int ret = 0;
 549         int brightness = -1;
 550         int maxBrightness = -1;
 551
 552         ClearLastResult();
 553
 554         ret = device_get_brightness(0, &brightness);
 555         if (ret != 0)
 556         {
 557                 SysLogException(NID_SYS, E_SYSTEM, "It failed to get the device brightness");
 558                 SetLastResult(E_SYSTEM);
 559                 return _DEACTIVATED_BRIGHTNESS_CONTROL;
 560         }
 561
 562         if (brightness == 0)
 563         {
 564                 brightness = 1;
 565         }
 566
 567         SysLog(NID_SYS, "System Brightness is %d", brightness);
 568         ret = device_get_max_brightness(0, &maxBrightness);
 569         if (ret != 0)
 570         {
 571                 SysLogException(NID_SYS, E_SYSTEM, "It failed to get the device max brightness");
 572                 SetLastResult(E_SYSTEM);
 573                 return _DEACTIVATED_BRIGHTNESS_CONTROL;
 574         }
 575         return ceil(((_BRIGHTNESS_RESOLUTION / (float) maxBrightness)) * brightness);
 576 }
 577
 578 bool
 579 _PowerManagerImpl::IsScreenOn(void)
 580 {
 581         power_state_e powerState = power_get_state();
 582
 583         if (powerState == POWER_STATE_SCREEN_OFF)
 584         {
 585                 return false;
 586         }
 587         else
 588         {
 589                 return true;
 590         }
 591 }
 592
 593 result
 594 _PowerManagerImpl::TurnScreenOn(void)
 595 {
 596         result r = E_SUCCESS;
 597         int ret = power_wakeup(true);
 598
 599         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to unlock the normal screen state");
 600
 601         return r;
 602 }
 603
 604 result
 605 _PowerManagerImpl::TurnScreenOff(void)
 606 {
 607         result r = E_SUCCESS;
 608         int ret = pm_change_state(LCD_OFF);
 609
 610         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to unlock the screen off screen state");
 611
 612         return r;
 613 }
 614
 615 void
 616 _PowerManagerImpl::SetScreenEventListener(IScreenEventListener& listener)
 617 {
 618         result r = E_SUCCESS;
 619
 620         r = AddScreenEventListener(listener, true);
 621
 622         if (IsFailed(r))
 623         {
 624                 SysLog(NID_SYS, "It failed to register ScreenEventListener");
 625                 return;
 626         }
 627         SysLog(NID_SYS,"It successed to register ScreenEventListener");
 628 }
 629
 630
 631 result
 632 _PowerManagerImpl::AddScreenEventListener(IScreenEventListener& listener, bool isSet)
 633 {
 634         result r = E_SUCCESS;
 635
 636         if (__pSceenEventList == null)
 637         {
 638                 std::unique_ptr< ArrayListT<IScreenEventListener*> > pSceenEventList(new ArrayListT<IScreenEventListener*>);
 639                 SysTryReturnResult(NID_SYS, pSceenEventList, E_SYSTEM, "Memory allocation failed");
 640                 pSceenEventList->Construct();
 641                 int errorCode = 0;
 642                 errorCode = vconf_notify_key_changed(VCONFKEY_PM_CURRENT_BRIGHTNESS, ScreenEventVConfCallback, null);
 643                 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add ScreenEvent listener.");
 644
 645                 errorCode = power_set_changed_cb(PowerChangedCallback, null);
 646                 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add ScreenEvent listener.");
 647                 __pSceenEventList = pSceenEventList.release();
 648                 SysLog(NID_SYS,"It successed to register power_set_changed_cb");
 649         }
 650
 651         if (isSet == true && __pSceenEventList->GetCount() != 0)
 652         {
 653                 r = __pSceenEventList->SetAt(&listener, 0);
 654         }
 655         else
 656         {
 657                 r = __pSceenEventList->Add(&listener);
 658         }
 659         return r;
 660 }
 661
 662
 663 result
 664 _PowerManagerImpl::RemoveScreenEventListener(IScreenEventListener& listener)
 665 {
 666         result r = E_SUCCESS;
 667
 668         SysTryReturnResult(NID_SYS,__pSceenEventList != null, E_OBJ_NOT_FOUND, "IScreenEventListener list is empty");
 669
 670         r = __pSceenEventList->Remove(&listener);
 671
 672         if (__pSceenEventList->GetCount() == 0)
 673         {
 674                 delete __pSceenEventList;
 675                 __pSceenEventList = null;
 676         }
 677         return r;
 678 }
 679
 680
 681 void
 682 _PowerManagerImpl::SetChargingEventListener(IChargingEventListener& listener)
 683 {
 684         result r = E_SUCCESS;
 685
 686         r = AddChargingEventListener(listener, true);
 687
 688         if (IsFailed(r))
 689         {
 690                 SysLog(NID_SYS, "It failed to register battery charging  event");
 691                 return;
 692         }
 693 }
 694
 695
 696 result
 697 _PowerManagerImpl::AddChargingEventListener(IChargingEventListener& listener, bool isSet)
 698 {
 699         result r = E_SUCCESS;
 700
 701         if (__pChargingEventList == null)
 702         {
 703                 __pChargingEventList = new ArrayListT<IChargingEventListener*>;
 704                 SysTryReturnResult(NID_SYS, __pChargingEventList, E_SYSTEM, "Memory allocation failed");
 705                 __pChargingEventList->Construct();
 706                 int errorCode = 0;
 707                 errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, RuntimeInfoChangedCallback, null);
 708                 if (errorCode != 0)
 709                 {
 710                         SysLog(NID_SYS, "It failed to register battery charging  event");
 711                         delete __pChargingEventList;
 712                         __pChargingEventList = null;
 713                         return E_SYSTEM;
 714                 }
 715         }
 716
 717         if (isSet == false || __pChargingEventList->GetCount() == 0)
 718         {
 719                 r = __pChargingEventList->Add(&listener);
 720         }
 721         else
 722         {
 723                 r = __pChargingEventList->SetAt(&listener, 0);
 724         }
 725         return r;
 726 }
 727
 728
 729 result
 730 _PowerManagerImpl::RemoveChargingEventListener(IChargingEventListener& listener)
 731 {
 732         result r = E_SUCCESS;
 733
 734         SysTryReturnResult(NID_SYS,__pChargingEventList != null, E_OBJ_NOT_FOUND, "__pChargingEventList list is empty");
 735
 736         r = __pChargingEventList->Remove(&listener);
 737
 738         if (__pChargingEventList->GetCount() == 0)
 739         {
 740                 delete __pChargingEventList;
 741                 __pChargingEventList = null;
 742         }
 743         return r;
 744 }
 745
 746 result
 747 _PowerManagerImpl::SetBatteryEventListener(IBatteryEventListener* pListener)
 748 {
 749         int ret = 0;
 750
 751         if (pListener != null)
 752         {
 753
 754                 if(pIBatteryEventListener == null)
 755                 {
 756                         ret = device_battery_set_cb(DeviceBatteryCallback, null);
 757                         if (ret != 0)
 758                         {
 759                                 SysLog(NID_SYS, "It failed to register battery event");
 760                         }
 761                 }
 762                 pIBatteryEventListener = pListener;
 763         }
 764         else
 765         {
 766                 pIBatteryEventListener = null;
 767                 ret = device_battery_unset_cb();
 768                 if (ret != 0)
 769                 {
 770                         SysLog(NID_SYS, "It failed to unregister battery event");
 771                 }
 772
 773         }
 774         return E_SUCCESS;
 775 }
 776
 777 result
 778 _PowerManagerImpl::PowerControl(int deviceId, int level)
 779 {
 780         int ret = 0;
 781         if(deviceId == _DEVICE_CPU)
 782         {
 783                 if(level == _DEVICE_POWER_LEVEL_ON)
 784                 {
 785                         ret = power_lock_state(POWER_STATE_SCREEN_OFF, 0);
 786                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the power state");
 787                         _deviceCpuPowerOn = true;
 788
 789                         return E_SUCCESS;
 790                 }
 791                 else if(level == _DEVICE_POWER_LEVEL_OFF)
 792                 {
 793                         if(_keepScreenOnState == false)
 794                         {
 795                                 ret = power_unlock_state(POWER_STATE_SCREEN_OFF);
 796                                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the power state");
 797                         }
 798                         _deviceCpuPowerOn = false;
 799                         return E_SUCCESS;
 800                 }
 801         }
 802         return E_SYSTEM;
 803 }
 804
 805 int
 806 _PowerManagerImpl::GetCurrentBatteryLevelInPercentage(void)
 807 {
 808         int ret = 0;
 809         int batteryLevel = 0;
 810
 811         ret = device_battery_get_percent(&batteryLevel);
 812         if(ret != 0)
 813         {
 814                 SetLastResult(E_SYSTEM);
 815         }
 816
 817         return batteryLevel;
 818 }
 819
 820 BatteryLevel
 821 _PowerManagerImpl::GetCurrentBatteryLevel(void)
 822 {
 823         int ret = 0;
 824         //int batteryLevel = 0;
 825         BatteryLevel level = BATTERY_FULL;
 826         device_battery_warn_e batteryStatus = DEVICE_BATTERY_WARN_EMPTY;
 827
 828         ret = device_battery_get_warning_status(&batteryStatus);
 829         if(ret != 0)
 830         {
 831                 SetLastResult(E_SYSTEM);
 832                 return level;
 833         }
 834
 835         switch (batteryStatus)
 836         {
 837         case DEVICE_BATTERY_WARN_FULL:
 838                 level = BATTERY_LEVEL_FULL;
 839                 break;
 840         case DEVICE_BATTERY_WARN_NORMAL:
 841                 level = BATTERY_LEVEL_HIGH;
 842                 break;
 843         case DEVICE_BATTERY_WARN_LOW:
 844                 level = BATTERY_LEVEL_LOW;
 845                 break;
 846         case DEVICE_BATTERY_WARN_CRITICAL:
 847                 level = BATTERY_LEVEL_CRITICAL;
 848                 break;
 849         case DEVICE_BATTERY_WARN_EMPTY:
 850                 level = BATTERY_LEVEL_EMPTY;
 851                 break;
 852         default:
 853                 SysLogException(NID_SYS, E_SYSTEM, "There is a system error occured.");
 854                 SetLastResult(E_SYSTEM);
 855                 return level;
 856         }
 857         SetLastResult(E_SUCCESS);
 858         return level;
 859 }
 860
 861 bool
 862 _PowerManagerImpl::IsCharging(void)
 863 {
 864         bool chargeState = false;
 865         int ret = 0;
 866         ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, &chargeState);
 867         if(ret != 0)
 868         {
 869                 SetLastResult(E_SYSTEM);
 870                 return chargeState;
 871         }
 872
 873         return chargeState;
 874 }
 875
 876 result
 877 _PowerManagerImpl::Add_IPowerManagerEventListener(_IPowerManagerEventListener* listener)
 878 {
 879         _PowerManagerImpl::Init();
 880         __powerEventList.Add(listener);
 881         return E_SUCCESS;
 882 }
 883
 884 result
 885 _PowerManagerImpl::Remove_IPowerManagerEventListener(_IPowerManagerEventListener* listener)
 886 {
 887         _PowerManagerImpl::Init();
 888         __powerEventList.Remove(listener);
 889         return E_SUCCESS;
 890 }
 891
 892 static void
 893 BootEventVconfCallback(keynode_t* node, void* userData)
 894 {
 895         if (__pBootEventList == null)
 896         {
 897                 SysLogException(NID_SYS, E_SYSTEM, "BootEventList is not initialized.");
 898                 return;
 899         }
 900
 901         int bootReady = -1;
 902         const int errorCode = vconf_get_int(VCONFKEY_SERVICE_READY, &bootReady);
 903
 904         if (errorCode != 0)
 905         {
 906                 SysLogException(NID_SYS, E_SYSTEM, "It failed to get Boot event status");
 907                 return;
 908         }
 909
 910         std::unique_ptr< IEnumeratorT<IBootEventListener*> > pEnum(__pBootEventList->GetEnumeratorN());
 911
 912         if (pEnum.get())
 913         {
 914                 while (pEnum->MoveNext() == E_SUCCESS)
 915                 {
 916                         IBootEventListener* pListener = null;
 917                         pEnum->GetCurrent(pListener);
 918
 919                         pListener->OnBootCompleted();
 920                 }
 921         }
 922
 923         SysLog(NID_SYS, "Finished invoking boot complete event listener.");
 924 }
 925
 926 result
 927 _PowerManagerImpl::AddBootEventListener(IBootEventListener& listener)
 928 {
 929         if (__pBootEventList == null)
 930         {
 931                 std::unique_ptr< ArrayListT<IBootEventListener*> > pBootEventList(new ArrayListT<IBootEventListener*>);
 932                 SysTryReturnResult(NID_SYS, pBootEventList, E_SYSTEM, "Memory allocation failed");
 933                 pBootEventList->Construct();
 934
 935                 int errorCode = 0;
 936                 errorCode = vconf_notify_key_changed(VCONFKEY_SERVICE_READY, BootEventVconfCallback, null);
 937                 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add BootEvent listener.");
 938
 939                 __pBootEventList = pBootEventList.release();
 940                 SysLog(NID_SYS, "It successed to register boot event listener.");
 941         }
 942
 943         return __pBootEventList->Add(&listener);
 944 }
 945
 946 result
 947 _PowerManagerImpl::RemoveBootEventListener(IBootEventListener& listener)
 948 {
 949         result r = E_SUCCESS;
 950
 951         SysTryReturnResult(NID_SYS,__pBootEventList != null, E_OBJ_NOT_FOUND, "IBootEventListener list is empty");
 952
 953         r = __pBootEventList->Remove(&listener);
 954
 955         if (__pBootEventList->GetCount() == 0)
 956         {
 957                 delete __pBootEventList;
 958                 __pBootEventList = null;
 959         }
 960
 961         return E_SUCCESS;
 962 }
 963
 964 _PowerManagerImpl*
 965 _PowerManagerImpl::GetInstance(PowerManager& powerManager)
 966 {
 967         return powerManager.__pPowerManagerImpl;
 968 }
 969
 970 const _PowerManagerImpl*
 971 _PowerManagerImpl::GetInstance(const PowerManager& powerManager)
 972 {
 973         return powerManager.__pPowerManagerImpl;
 974 }
 975 } } //Tizen::System