src/system/FSys_PowerManagerImpl.cpp

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