src/Power/PowerManager.cpp

   1 //
   2 // Tizen Web Device API
   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 #include "PowerManager.h"
  19 #include <cstring>
  20 #include <power.h>
  21 #include <pmapi.h>
  22 #include <device.h>
  23 #include <dlog.h>
  24 #include <algorithm>
  25 #include <PlatformException.h>
  26 #include <Logger.h>
  27 #include <JSUtil.h>
  28
  29 using namespace DeviceAPI::Common;
  30 using namespace std;
  31
  32 namespace DeviceAPI {
  33 namespace Power {
  34
  35
  36 PowerResource::PowerResource(const char *resource)
  37 {
  38     if( strcmp(resource,"SCREEN") == 0 )
  39         mType = SCREEN;
  40     else if( strcmp(resource,"CPU") == 0 )
  41        mType = CPU;
  42     else
  43        throw TypeMismatchException("value is not PowerResource type");
  44 };
  45
  46 const std::string PowerResource::toString(){
  47     static const char *table[] = {"SCREEN", "CPU"};
  48     return std::string(table[mType]);
  49 }
  50
  51
  52 PowerState::PowerState(const char *str)
  53 {
  54     static const char *table[] = { "SCREEN_OFF", "SCREEN_DIM", "SCREEN_NORMAL", "SCREEN_BRIGHT", "CPU_AWAKE"};
  55     static state state_table[] = { SCREENOFF, SCREENDIM, SCREENNORMAL, SCREENBRIGHT, CPUAWAKE };
  56     for(unsigned int i =0; i < sizeof(table)/sizeof(char*) ; i++){
  57         if( strcmp(str, table[i]) == 0 ){
  58             mState = state_table[i];
  59             return;
  60         }
  61     }
  62     throw TypeMismatchException("value is not PowerState type");
  63 };
  64
  65 PowerState::PowerState(state in):mState(in){
  66 }
  67
  68 const std::string PowerState::toString(){
  69     static const char *table[] = { "SCREEN_OFF", "SCREEN_DIM", "SCREEN_NORMAL", "SCREEN_BRIGHT", "CPU_AWAKE"};
  70     return std::string(table[mState]);
  71 }
  72
  73
  74 void PowerManager::onPlatformStateChangedCB(power_state_e state, void *user_data){
  75     PowerManager* object = static_cast<PowerManager*>(user_data);
  76     if(object == NULL){
  77         LOGE("User data is NULL");
  78         return;
  79     }
  80     PowerState current(PowerState::SCREENOFF);
  81     switch( state ){
  82         case POWER_STATE_NORMAL :
  83             current.mState = object->mBrightStateEnable ? PowerState::SCREENBRIGHT : PowerState::SCREENNORMAL;
  84             break;
  85         case POWER_STATE_SCREEN_DIM :
  86             current.mState = PowerState::SCREENDIM;
  87             break;
  88         case POWER_STATE_SCREEN_OFF :
  89             current.mState = PowerState::SCREENOFF;
  90             break;
  91     }
  92     object->broadcastScreenState(current);
  93 }
  94
  95
  96 void PowerManager::request(PowerResource resource, PowerState state){
  97     if( resource == PowerResource::SCREEN && state == PowerState::CPUAWAKE)
  98         throw InvalidValuesException("invalid PowerState");
  99     if( resource == PowerResource::CPU && state != PowerState::CPUAWAKE)
 100         throw InvalidValuesException("invalid PowerState");
 101
 102     int ret=0;
 103     int native_state = POWER_STATE_SCREEN_OFF;
 104     switch( state ){
 105         case PowerState::SCREENDIM :
 106             native_state = POWER_STATE_SCREEN_DIM;
 107         case PowerState::SCREENNORMAL :
 108             native_state = POWER_STATE_NORMAL;
 109         case PowerState::CPUAWAKE :
 110             ret = power_lock_state( state.mState == PowerState::SCREENDIM ? POWER_STATE_SCREEN_DIM : POWER_STATE_NORMAL, 0);
 111             if( POWER_ERROR_NONE!=ret )
 112                 throw UnknownException("power_lock_state error");
 113             break;
 114         case PowerState::SCREENBRIGHT :
 115         {
 116             int maxBrightness;
 117             ret = device_get_max_brightness(0, &maxBrightness);
 118             if( DEVICE_ERROR_NONE!=ret) {
 119                 LOGE("Platform error while getting max brightness: %d", ret);
 120                 throw UnknownException("Platform error while getting max brightness");
 121             }
 122
 123             ret = device_set_brightness(0, maxBrightness);
 124             if( DEVICE_ERROR_NONE!=ret)
 125                 throw UnknownException("Platform error while setting max brightness:");
 126
 127             LOGI("Succeeded setting the brightness to a max level: %d", maxBrightness);
 128             ret = power_lock_state(POWER_STATE_NORMAL, 0);
 129             if( POWER_ERROR_NONE!=ret )
 130                 throw UnknownException("Platform error while locking state");
 131
 132             mBrightStateEnable = true;
 133             power_state_e platform_state = power_get_state();
 134             if( platform_state ==  POWER_STATE_NORMAL)
 135                 broadcastScreenState(PowerState::SCREENBRIGHT);
 136             break;
 137         }
 138         default :
 139             throw UnknownException("Platform error while locking state");
 140     }
 141 }
 142
 143 void PowerManager::release(PowerResource resource){
 144     int ret;
 145     if( PowerResource::SCREEN == resource ) {
 146         ret = power_unlock_state(POWER_STATE_SCREEN_DIM);
 147         if( POWER_ERROR_NONE!=ret )
 148             LOGI("Platform return value from dim unlock: %d", ret);
 149
 150         ret = power_unlock_state(POWER_STATE_NORMAL);
 151         if( POWER_ERROR_NONE!=ret )
 152             LOGI("Platform return value from dim unlock: %d", ret);
 153
 154         ret = device_set_brightness_from_settings(0);
 155         if( DEVICE_ERROR_NONE!=ret)
 156             throw UnknownException("Platform error while setting restore brightness");
 157
 158         mBrightStateEnable = false;
 159         power_state_e platform_state = power_get_state();
 160         if( platform_state ==  POWER_STATE_NORMAL)
 161             broadcastScreenState(PowerState::SCREENNORMAL);
 162
 163     } else if( PowerResource::CPU == resource ) {
 164         ret = power_unlock_state(POWER_STATE_SCREEN_OFF);
 165         if( POWER_ERROR_NONE!=ret )
 166             LOGI("Platform return value from off unlock: %d", ret);
 167     }
 168 }
 169
 170 double PowerManager::getScreenBrightness(){
 171     int ret, brightness;
 172     ret = device_get_brightness(0, &brightness);
 173     if( DEVICE_ERROR_NONE!=ret )
 174         throw UnknownException("Platform error while get brightness");
 175     LOGI("Brightness value: %d", brightness);
 176     return brightness/100.0;
 177 }
 178
 179 void PowerManager::setScreenBrightness(double brightness){
 180     int ret;
 181     if( brightness > 1 || brightness < 0 )
 182         throw InvalidValuesException("brightness should be 0 <= brightness <= 1");
 183     int maxBrightness;
 184     ret = device_get_max_brightness(0, &maxBrightness);
 185     if( ret != 0 ){
 186         LOGE("Platform error while setting restore brightness: %d", ret);
 187         throw UnknownException("Platform error while getting max brightness");
 188     }
 189
 190     ret = device_set_brightness(0, (int)(brightness*maxBrightness));
 191     if( DEVICE_ERROR_NONE!=ret )
 192         throw UnknownException("Platform error while setting brightness.");
 193     LOGI("Set the brightness value: %d", (int)(brightness*maxBrightness));
 194 }
 195
 196 bool PowerManager::isScreenOn(){
 197     power_state_e state = power_get_state();
 198     if(POWER_STATE_SCREEN_OFF==state)
 199         return false;
 200     else
 201         return true;
 202 }
 203
 204 void PowerManager::setScreenState(bool onoff){
 205     int ret = 0;
 206     if( onoff )
 207         ret = pm_change_state(LCD_NORMAL);
 208     else
 209         ret = pm_change_state(LCD_OFF);
 210
 211     if( ret<0 )
 212         throw UnknownException("Platform error while changing screen state");
 213 }
 214
 215 void PowerManager::restoreScreenBrightness(){
 216     int ret;
 217     ret = device_set_brightness_from_settings(0);
 218     if( DEVICE_ERROR_NONE!=ret)
 219         throw UnknownException("Platform error while restoring brightness");
 220 }
 221
 222 PowerManager* PowerManager::getInstance(){
 223     static PowerManager instance;
 224     return &instance;
 225 }
 226
 227 void PowerManager::addScreenStateChangedCallback(Common::CallbackUserData * callback){
 228     list<CallbackUserData*>::iterator itr;
 229     itr = find(mListener.begin(), mListener.end(), callback);
 230     if( itr == mListener.end() )
 231         mListener.push_back(callback);
 232 }
 233
 234 void PowerManager::removeScreenStateChangedCallback(Common::CallbackUserData * callback){
 235     mListener.remove(callback);
 236 }
 237
 238 void PowerManager::broadcastScreenState(PowerState current){
 239     if( mCurrentState == current)
 240         return;
 241
 242     list<CallbackUserData*> tmplist(mListener);
 243     list<CallbackUserData*>::iterator itr = tmplist.begin();
 244
 245     while( itr != tmplist.end() ){
 246         CallbackUserData *callback = *itr;
 247         if( callback != NULL ){
 248             JSValueRef previousState = JSUtil::toJSValueRef(callback->getContext(), mCurrentState.toString());
 249             JSValueRef currentState = JSUtil::toJSValueRef(callback->getContext(), current.toString());
 250             JSValueRef args[2] = { previousState, currentState };
 251             callback->callSuccessCallback(2, args);
 252         }
 253         ++itr;
 254     }
 255     mCurrentState = current;
 256 }
 257
 258
 259 PowerManager::PowerManager():mCurrentState(PowerState::SCREENNORMAL),mBrightStateEnable(false){
 260     power_state_e platform_state = power_get_state();
 261     switch( platform_state ){
 262         case POWER_STATE_NORMAL :
 263             mCurrentState.mState = PowerState::SCREENNORMAL;
 264             break;
 265         case POWER_STATE_SCREEN_DIM :
 266             mCurrentState.mState = PowerState::SCREENDIM;
 267             break;
 268         case POWER_STATE_SCREEN_OFF :
 269             mCurrentState.mState = PowerState::SCREENOFF;
 270             break;
 271     }
 272     power_set_changed_cb(PowerManager::onPlatformStateChangedCB, this);
 273 }
 274 PowerManager::~PowerManager(){
 275     power_unset_changed_cb();
 276 }
 277
 278 } //Power
 279 } //DeviceAPI
 280