src/system/FSys_PowerManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FSys_PowerManagerImpl.cpp
  20  * @brief               This is the implementation file for _PowerManagerImpl class.
  21  */
  22
  23 #include <unique_ptr.h>
  24
  25 #include <pmapi.h>
  26 #include <power.h>
  27 #include <device.h>
  28 #include <runtime_info.h>
  29 #include <vconf.h>
  30
  31 #include <FAppIActiveAppEventListener.h>
  32 #include <FBaseSysLog.h>
  33 #include <FBaseColArrayListT.h>
  34 #include <FBaseColIMapEnumerator.h>
  35 #include <FSysIBatteryEventListener.h>
  36 #include <FSysIChargingEventListener.h>
  37 #include <FSysIScreenEventListener.h>
  38 #include <FSysIBootEventListener.h>
  39 #include <FSys_IPowerManagerEventListener.h>
  40
  41 #include <FApp_AppImpl.h>
  42 #include <FApp_AppInfo.h>
  43 #include <FApp_AppManagerImpl.h>
  44 #include <FBase_NativeError.h>
  45 #include <FIo_AppServiceIpcMessages.h>
  46 #include <FIo_IpcClient.h>
  47 #include <FSys_Types.h>
  48 #include <FSys_BatteryImpl.h>
  49 #include <FSys_DeviceManagerImpl.h>
  50 #include <FSys_PowerManagerImpl.h>
  51
  52 using namespace std;
  53
  54 using namespace Tizen::App;
  55 using namespace Tizen::Base;
  56 using namespace Tizen::Base::Collection;
  57 using namespace Tizen::Io;
  58
  59 namespace Tizen { namespace System
  60 {
  61
  62 static const int _DEVICE_CPU = 1;
  63 static const int _DEVICE_POWER_LEVEL_ON = 1;
  64 static const int _DEVICE_POWER_LEVEL_OFF = 0;
  65 static const int _APPID_LENGTH = 10;
  66 static const int _DEACTIVATED_BRIGHTNESS_CONTROL = -1;
  67 static const float _BRIGHTNESS_RESOLUTION = 10.0;
  68
  69 #ifndef VCONFKEY_SERVICE_READY
  70 #define VCONFKEY_SERVICE_READY  "memory/appservice/serviceready"
  71 #endif
  72
  73 bool _activeApp = false;
  74 bool _deviceCpuPowerOn = false;
  75 bool _keepCpuAwake = false;
  76 bool _keepScreenOnState = false;
  77
  78 IBatteryEventListener* pIBatteryEventListener = null;
  79
  80 ArrayListT<IScreenEventListener*>*      __pSceenEventList = null;
  81 ArrayListT<IChargingEventListener*>*    __pChargingEventList = null;
  82 ArrayListT<_IPowerManagerEventListener*>        __powerEventList;
  83 ArrayListT<IBootEventListener*>*        __pBootEventList = null;
  84
  85 bool _PowerManagerImpl::_InitPowerManager = false;
  86
  87
  88 class _ActiveEventListener
  89         : public IActiveAppEventListener
  90 {
  91 public:
  92         virtual void OnActiveAppChanged(const Tizen::App::AppId& appId);
  93 };
  94
  95 void
  96 _ActiveEventListener::OnActiveAppChanged(const Tizen::App::AppId& appId)
  97 {
  98         int ret = 0;
  99         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_EMPTY;
 147                                 break;
 148                         case VCONFKEY_SYSMAN_BAT_LEVEL_HIGH:
 149                                 batteryLevel = BATTERY_EMPTY;
 150                                 break;
 151                         case VCONFKEY_SYSMAN_BAT_LEVEL_FULL:
 152                                 batteryLevel = BATTERY_EMPTY;
 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
 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                         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;
 385         _PowerManagerImpl::Init();
 386
 387         if (keepOn == true && IsActive() == true)
 388         {
 389                 if (dimming)
 390                 {
 391                         state = LCD_DIM;
 392                 }
 393                 else
 394                 {
 395                         state = LCD_NORMAL;
 396                 }
 397                 ret = pm_lock_state(state, GOTO_STATE_NOW, 0);
 398                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the screen state");
 399                 _keepScreenOnState = true;
 400         }
 401         else
 402         {
 403                 ret = pm_unlock_state(LCD_NORMAL, GOTO_STATE_NOW);
 404                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the screen state");
 405                 _keepScreenOnState = false;
 406         }
 407
 408         SysLog(NID_SYS, "change screen power policy: keepOn(%d) and dimming(%d)", keepOn, dimming);
 409
 410         return E_SUCCESS;
 411 }
 412
 413 result
 414 _PowerManagerImpl::KeepCpuAwake(bool enable)
 415 {
 416         int ret = 0;
 417         _PowerManagerImpl::Init();
 418
 419         if (enable)
 420         {
 421                 ret = power_lock_state(POWER_STATE_SCREEN_OFF, 0);
 422                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the power state");
 423                 _keepCpuAwake = true;
 424         }
 425         else
 426         {
 427                  if(_deviceCpuPowerOn == false)
 428                 {
 429                         ret = power_unlock_state(POWER_STATE_SCREEN_OFF);
 430                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the power state");
 431                 }
 432                 _keepCpuAwake = false;
 433         }
 434
 435         SysLog(NID_SYS, "change cpu power policy: keepAwake(%s)", enable ? "true" : "false");
 436         return E_SUCCESS;
 437 }
 438
 439 result
 440 _PowerManagerImpl::InitBatteryEvent(void)
 441 {
 442         int ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, BatteryLevelVConfCallback, null);
 443         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to set the battery event");
 444
 445         return E_SUCCESS;
 446 }
 447
 448 result
 449 _PowerManagerImpl::OnForeground(void)
 450 {
 451         return E_SUCCESS;
 452 }
 453
 454 result
 455 _PowerManagerImpl::OnBackground(void)
 456 {
 457         return E_SUCCESS;
 458 }
 459
 460 result
 461 _PowerManagerImpl::RestoreScreenBrightness(void)
 462 {
 463         result r = E_SUCCESS;
 464
 465         ArrayList requestMessage;
 466         ArrayList responseMessage;
 467
 468         SysTryReturn(NID_SYS, IsActive() == true, E_SUCCESS, r, "It is not active app.");
 469
 470         unique_ptr<_IpcClient> pIpcClient (new (std::nothrow) _IpcClient());
 471         SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
 472
 473         r = pIpcClient->Construct(_COMMUNICATION_DISPATCHER_IPC_ID);
 474         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to create IpcClient", GetErrorMessage(r));
 475
 476         requestMessage.Construct();
 477         responseMessage.Construct();
 478
 479         String serviceId = _SYSTEM_SERVICE_ID;
 480         String commandId = _SYSTEM_COMMAND_RESTORE_BRIGHTNESS;
 481
 482         requestMessage.Add(serviceId);
 483         requestMessage.Add(commandId);
 484
 485         unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
 486         SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
 487
 488         r = pIpcClient->SendRequest(pMsg.get());
 489         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to ipc message", GetErrorMessage(r));
 490
 491         unique_ptr<String> pResult((String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA));
 492
 493         SysTryReturnResult(NID_SYS, pResult != null, E_SYSTEM, "It is failed to receive Ipc response.");
 494         SysTryReturnResult(NID_SYS, *pResult == _SYSTEM_RESULT_OK, E_SYSTEM, "It is failed to set brightness.");
 495
 496         return E_SUCCESS;
 497 }
 498
 499 result
 500 _PowerManagerImpl::SetScreenBrightness(int brightness)
 501 {
 502         int ret = 0;
 503         int maxBrightness = 0;
 504         int actualBrightness = 0;
 505         result r = E_SUCCESS;
 506
 507         SysTryReturn(NID_SYS, IsActive() == true, E_SUCCESS, r, "It is not active app.");
 508         SysTryReturnResult(NID_SYS, (brightness > 0 && brightness < 11), E_OUT_OF_RANGE,
 509                                           "[E_OUT_OF_RANGE] The specified brightness is out of range.");
 510
 511         SysLog(NID_SYS, "Set brightness (%d)", brightness);
 512
 513         ret = device_get_max_brightness(0, &maxBrightness);
 514         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to get the device max brightness");
 515
 516         actualBrightness = maxBrightness * brightness / _BRIGHTNESS_RESOLUTION;
 517
 518         ArrayList requestMessage;
 519         ArrayList responseMessage;
 520
 521         unique_ptr<_IpcClient> pIpcClient (new (std::nothrow) _IpcClient());
 522         SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
 523
 524         r = pIpcClient->Construct(_COMMUNICATION_DISPATCHER_IPC_ID);
 525         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to create IpcClient", GetErrorMessage(r));
 526
 527         requestMessage.Construct();
 528         responseMessage.Construct();
 529
 530         String serviceId = _SYSTEM_SERVICE_ID;
 531         String commandId = _SYSTEM_COMMAND_CHANGE_BRIGHTNESS;
 532         String brightnessValue;
 533         brightnessValue.Append(actualBrightness);
 534
 535         requestMessage.Add(serviceId);
 536         requestMessage.Add(commandId);
 537         requestMessage.Add(brightnessValue);
 538
 539         unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
 540         SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
 541
 542         r = pIpcClient->SendRequest(pMsg.get());
 543         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] It failed to ipc message", GetErrorMessage(r));
 544
 545         unique_ptr<String> pResult((String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA));
 546
 547         SysTryReturnResult(NID_SYS, pResult != null, E_SYSTEM, "It is failed to receive Ipc response.");
 548         SysTryReturnResult(NID_SYS, *pResult == _SYSTEM_RESULT_OK, E_SYSTEM, "It is failed to set brightness.");
 549
 550         return E_SUCCESS;
 551 }
 552
 553 int
 554 _PowerManagerImpl::GetScreenBrightness(void)
 555 {
 556         int ret = 0;
 557         int brightness = -1;
 558         int maxBrightness = -1;
 559
 560         ClearLastResult();
 561
 562         ret = device_get_brightness(0, &brightness);
 563         if (ret != 0)
 564         {
 565                 SysLogException(NID_SYS, E_SYSTEM, "It failed to get the device brightness");
 566                 SetLastResult(E_SYSTEM);
 567                 return _DEACTIVATED_BRIGHTNESS_CONTROL;
 568         }
 569
 570         if (brightness == 0)
 571         {
 572                 brightness = 1;
 573         }
 574
 575         SysLog(NID_SYS, "System Brightness is %d", brightness);
 576         ret = device_get_max_brightness(0, &maxBrightness);
 577         if (ret != 0)
 578         {
 579                 SysLogException(NID_SYS, E_SYSTEM, "It failed to get the device max brightness");
 580                 SetLastResult(E_SYSTEM);
 581                 return _DEACTIVATED_BRIGHTNESS_CONTROL;
 582         }
 583         return ceil(((_BRIGHTNESS_RESOLUTION / (float) maxBrightness)) * brightness);
 584 }
 585
 586 bool
 587 _PowerManagerImpl::IsScreenOn(void)
 588 {
 589         power_state_e powerState = power_get_state();
 590
 591         if (powerState == POWER_STATE_SCREEN_OFF)
 592         {
 593                 return false;
 594         }
 595         else
 596         {
 597                 return true;
 598         }
 599 }
 600
 601 result
 602 _PowerManagerImpl::TurnScreenOn(void)
 603 {
 604         result r = E_SUCCESS;
 605         int ret = power_wakeup(true);
 606
 607         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to unlock the normal screen state");
 608
 609         return r;
 610 }
 611
 612 result
 613 _PowerManagerImpl::TurnScreenOff(void)
 614 {
 615         result r = E_SUCCESS;
 616         int ret = pm_change_state(LCD_OFF);
 617
 618         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It failed to unlock the screen off screen state");
 619
 620         return r;
 621 }
 622
 623 void
 624 _PowerManagerImpl::SetScreenEventListener(IScreenEventListener& listener)
 625 {
 626         result r = E_SUCCESS;
 627
 628         r = AddScreenEventListener(listener, true);
 629
 630         if (IsFailed(r))
 631         {
 632                 SysLog(NID_SYS, "It failed to register ScreenEventListener");
 633                 return;
 634         }
 635         SysLog(NID_SYS,"It successed to register ScreenEventListener");
 636 }
 637
 638
 639 result
 640 _PowerManagerImpl::AddScreenEventListener(IScreenEventListener& listener, bool isSet)
 641 {
 642         result r = E_SUCCESS;
 643
 644         if (__pSceenEventList == null)
 645         {
 646                 std::unique_ptr< ArrayListT<IScreenEventListener*> > pSceenEventList(new ArrayListT<IScreenEventListener*>);
 647                 SysTryReturnResult(NID_SYS, pSceenEventList, E_SYSTEM, "Memory allocation failed");
 648                 pSceenEventList->Construct();
 649                 int errorCode = 0;
 650                 errorCode = vconf_notify_key_changed(VCONFKEY_PM_CURRENT_BRIGHTNESS, ScreenEventVConfCallback, null);
 651                 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add ScreenEvent listener.");
 652
 653                 errorCode = power_set_changed_cb(PowerChangedCallback, null);
 654                 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add ScreenEvent listener.");
 655                 __pSceenEventList = pSceenEventList.release();
 656                 SysLog(NID_SYS,"It successed to register power_set_changed_cb");
 657         }
 658
 659         if (isSet == true && __pSceenEventList->GetCount() != 0)
 660         {
 661                 r = __pSceenEventList->SetAt(&listener, 0);
 662         }
 663         else
 664         {
 665                 r = __pSceenEventList->Add(&listener);
 666         }
 667         return r;
 668 }
 669
 670
 671 result
 672 _PowerManagerImpl::RemoveScreenEventListener(IScreenEventListener& listener)
 673 {
 674         result r = E_SUCCESS;
 675
 676         SysTryReturnResult(NID_SYS,__pSceenEventList != null, E_OBJ_NOT_FOUND, "IScreenEventListener list is empty");
 677
 678         r = __pSceenEventList->Remove(&listener);
 679
 680         if (__pSceenEventList->GetCount() == 0)
 681         {
 682                 delete __pSceenEventList;
 683                 __pSceenEventList = null;
 684         }
 685         return r;
 686 }
 687
 688
 689 void
 690 _PowerManagerImpl::SetChargingEventListener(IChargingEventListener& listener)
 691 {
 692         result r = E_SUCCESS;
 693
 694         r = AddChargingEventListener(listener, true);
 695
 696         if (IsFailed(r))
 697         {
 698                 SysLog(NID_SYS, "It failed to register battery charging  event");
 699                 return;
 700         }
 701 }
 702
 703
 704 result
 705 _PowerManagerImpl::AddChargingEventListener(IChargingEventListener& listener, bool isSet)
 706 {
 707         result r = E_SUCCESS;
 708
 709         if (__pChargingEventList == null)
 710         {
 711                 __pChargingEventList = new ArrayListT<IChargingEventListener*>;
 712                 SysTryReturnResult(NID_SYS, __pChargingEventList, E_SYSTEM, "Memory allocation failed");
 713                 __pChargingEventList->Construct();
 714                 int errorCode = 0;
 715                 errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, RuntimeInfoChangedCallback, null);
 716                 if (errorCode != 0)
 717                 {
 718                         SysLog(NID_SYS, "It failed to register battery charging  event");
 719                         delete __pChargingEventList;
 720                         __pChargingEventList = null;
 721                         return E_SYSTEM;
 722                 }
 723         }
 724
 725         if (isSet == false || __pChargingEventList->GetCount() == 0)
 726         {
 727                 r = __pChargingEventList->Add(&listener);
 728         }
 729         else
 730         {
 731                 r = __pChargingEventList->SetAt(&listener, 0);
 732         }
 733         return r;
 734 }
 735
 736
 737 result
 738 _PowerManagerImpl::RemoveChargingEventListener(IChargingEventListener& listener)
 739 {
 740         result r = E_SUCCESS;
 741
 742         SysTryReturnResult(NID_SYS,__pChargingEventList != null, E_OBJ_NOT_FOUND, "__pChargingEventList list is empty");
 743
 744         r = __pChargingEventList->Remove(&listener);
 745
 746         if (__pChargingEventList->GetCount() == 0)
 747         {
 748                 delete __pChargingEventList;
 749                 __pChargingEventList = null;
 750         }
 751         return r;
 752 }
 753
 754 result
 755 _PowerManagerImpl::SetBatteryEventListener(IBatteryEventListener* pListener)
 756 {
 757         int ret = 0;
 758
 759         if (pListener != null)
 760         {
 761
 762                 if(pIBatteryEventListener == null)
 763                 {
 764                         ret = device_battery_set_cb(DeviceBatteryCallback, null);
 765                         if (ret != 0)
 766                         {
 767                                 SysLog(NID_SYS, "It failed to register battery event");
 768                         }
 769                 }
 770                 pIBatteryEventListener = pListener;
 771         }
 772         else
 773         {
 774                 pIBatteryEventListener = null;
 775                 ret = device_battery_unset_cb();
 776                 if (ret != 0)
 777                 {
 778                         SysLog(NID_SYS, "It failed to unregister battery event");
 779                 }
 780
 781         }
 782         return E_SUCCESS;
 783 }
 784
 785 result
 786 _PowerManagerImpl::PowerControl(int deviceId, int level)
 787 {
 788         int ret = 0;
 789         if(deviceId == _DEVICE_CPU)
 790         {
 791                 if(level == _DEVICE_POWER_LEVEL_ON)
 792                 {
 793                         ret = power_lock_state(POWER_STATE_SCREEN_OFF, 0);
 794                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to lock the power state");
 795                         _deviceCpuPowerOn = true;
 796
 797                         return E_SUCCESS;
 798                 }
 799                 else if(level == _DEVICE_POWER_LEVEL_OFF)
 800                 {
 801                         if(_keepScreenOnState == false)
 802                         {
 803                                 ret = power_unlock_state(POWER_STATE_SCREEN_OFF);
 804                                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] It failed to unlock the power state");
 805                         }
 806                         _deviceCpuPowerOn = false;
 807                         return E_SUCCESS;
 808                 }
 809         }
 810         return E_SYSTEM;
 811 }
 812
 813 int
 814 _PowerManagerImpl::GetCurrentBatteryLevelInPercentage(void)
 815 {
 816         int ret = 0;
 817         int batteryLevel = 0;
 818
 819         ret = device_battery_get_percent(&batteryLevel);
 820         if(ret != 0)
 821         {
 822                 SetLastResult(E_SYSTEM);
 823         }
 824
 825         return batteryLevel;
 826 }
 827
 828 BatteryLevel
 829 _PowerManagerImpl::GetCurrentBatteryLevel(void)
 830 {
 831         int batteryLevel = 0;
 832         BatteryLevel level = BATTERY_EMPTY;
 833         int ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, &batteryLevel);
 834         if(ret != 0)
 835         {
 836                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to get battery level.");
 837                 return level;
 838         }
 839
 840         switch(batteryLevel)
 841         {
 842         case VCONFKEY_SYSMAN_BAT_LEVEL_FULL:
 843                 level = BATTERY_LEVEL_FULL;
 844                 break;
 845         case VCONFKEY_SYSMAN_BAT_LEVEL_HIGH:
 846                 level = BATTERY_LEVEL_HIGH;
 847                 break;
 848         case VCONFKEY_SYSMAN_BAT_LEVEL_LOW:
 849                 level = BATTERY_LEVEL_LOW;
 850                 break;
 851         case VCONFKEY_SYSMAN_BAT_LEVEL_CRITICAL:
 852                 level = BATTERY_LEVEL_CRITICAL;
 853                 break;
 854         default:
 855                 level = BATTERY_LEVEL_EMPTY;
 856                 break;
 857         }
 858
 859         return level;
 860 }
 861
 862 bool
 863 _PowerManagerImpl::IsCharging(void)
 864 {
 865         bool chargeState = false;
 866         int ret = 0;
 867         ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, &chargeState);
 868         if(ret != 0)
 869         {
 870                 SetLastResult(E_SYSTEM);
 871                 return chargeState;
 872         }
 873
 874         return chargeState;
 875 }
 876
 877 result
 878 _PowerManagerImpl::Add_IPowerManagerEventListener(_IPowerManagerEventListener* listener)
 879 {
 880         _PowerManagerImpl::Init();
 881         __powerEventList.Add(listener);
 882         return E_SUCCESS;
 883 }
 884
 885 result
 886 _PowerManagerImpl::Remove_IPowerManagerEventListener(_IPowerManagerEventListener* listener)
 887 {
 888         _PowerManagerImpl::Init();
 889         __powerEventList.Remove(listener);
 890         return E_SUCCESS;
 891 }
 892
 893 static void
 894 BootEventVconfCallback(keynode_t* node, void* userData)
 895 {
 896         if (__pBootEventList == null)
 897         {
 898                 SysLogException(NID_SYS, E_SYSTEM, "BootEventList is not initialized.");
 899                 return;
 900         }
 901
 902         int bootReady = -1;
 903         const int errorCode = vconf_get_int(VCONFKEY_SERVICE_READY, &bootReady);
 904
 905         if (errorCode != 0)
 906         {
 907                 SysLogException(NID_SYS, E_SYSTEM, "It failed to get Boot event status");
 908                 return;
 909         }
 910
 911         std::unique_ptr< IEnumeratorT<IBootEventListener*> > pEnum(__pBootEventList->GetEnumeratorN());
 912
 913         if (pEnum.get())
 914         {
 915                 while (pEnum->MoveNext() == E_SUCCESS)
 916                 {
 917                         IBootEventListener* pListener = null;
 918                         pEnum->GetCurrent(pListener);
 919
 920                         pListener->OnBootCompleted();
 921                 }
 922         }
 923
 924         SysLog(NID_SYS, "Finished invoking boot complete event listener.");
 925 }
 926
 927 result
 928 _PowerManagerImpl::AddBootEventListener(IBootEventListener& listener)
 929 {
 930         if (__pBootEventList == null)
 931         {
 932                 std::unique_ptr< ArrayListT<IBootEventListener*> > pBootEventList(new ArrayListT<IBootEventListener*>);
 933                 SysTryReturnResult(NID_SYS, pBootEventList, E_SYSTEM, "Memory allocation failed");
 934                 pBootEventList->Construct();
 935
 936                 int errorCode = 0;
 937                 errorCode = vconf_notify_key_changed(VCONFKEY_SERVICE_READY, BootEventVconfCallback, null);
 938                 SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It failed to add BootEvent listener.");
 939
 940                 __pBootEventList = pBootEventList.release();
 941                 SysLog(NID_SYS, "It successed to register boot event listener.");
 942         }
 943
 944         return __pBootEventList->Add(&listener);
 945 }
 946
 947 result
 948 _PowerManagerImpl::RemoveBootEventListener(IBootEventListener& listener)
 949 {
 950         result r = E_SUCCESS;
 951
 952         SysTryReturnResult(NID_SYS,__pBootEventList != null, E_OBJ_NOT_FOUND, "IBootEventListener list is empty");
 953
 954         r = __pBootEventList->Remove(&listener);
 955
 956         if (__pBootEventList->GetCount() == 0)
 957         {
 958                 delete __pBootEventList;
 959                 __pBootEventList = null;
 960         }
 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