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