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