src/power/power_api.js

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   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 var JSON_ = xwalk.JSON;
  18 var validator_ = xwalk.utils.validator;
  19 var types_ = validator_.Types;
  20 var native_ = new xwalk.utils.NativeManager(extension);
  21 var privUtils_ = xwalk.utils;
  22 var T_ = xwalk.utils.type;
  23
  24 function ListenerManager(native, listenerName) {
  25     this.listener;
  26     this.native = native;
  27     this.listenerName = listenerName;
  28 }
  29
  30 ListenerManager.prototype.onListenerCalled = function(msg) {
  31     this.listener(msg.previousState, msg.changedState);
  32 };
  33
  34 ListenerManager.prototype.addListener = function(callback) {
  35     this.native.addListener(this.listenerName, this.onListenerCalled.bind(this));
  36     this.listener = callback;
  37 };
  38
  39 ListenerManager.prototype.removeListener = function() {
  40     this.native.removeListener(this.listenerName);
  41     delete this.listener;
  42 };
  43
  44 ListenerManager.prototype.isListenerSet = function() {
  45     return this.native.isListenerSet(this.listenerName);
  46 };
  47
  48 var screenStateChangeListener = new ListenerManager(native_, 'ScreenStateChangeListener');
  49
  50 var PowerResource = {
  51     SCREEN: 'SCREEN',
  52     CPU: 'CPU'
  53 };
  54
  55 /**
  56  * An enumerator that indicates the power state for screen resource.
  57  * @enum {string}
  58  */
  59 var PowerScreenState = {
  60     SCREEN_OFF: 'SCREEN_OFF',
  61     SCREEN_DIM: 'SCREEN_DIM',
  62     SCREEN_NORMAL: 'SCREEN_NORMAL',
  63     SCREEN_BRIGHT: 'SCREEN_BRIGHT'
  64 };
  65
  66 /**
  67  * An enumerator that indicates the power state for cpu resource.
  68  * @enum {string}
  69  */
  70 var PowerCpuState = {
  71     CPU_AWAKE: 'CPU_AWAKE'
  72 };
  73
  74 var PowerState = Object.assign({}, PowerScreenState, PowerCpuState);
  75
  76 /**
  77  * This class provides functions to request and release power resource.
  78  * @constructor
  79  */
  80 function PowerManager() {
  81     // constructor of PowerManager
  82 }
  83
  84 /**
  85  * Requests the minimum-state for a power resource.
  86  * @param {!PowerResource} resource The power resource for which the request
  87  *     is made.
  88  * @param {!PowerState} state The minimal state in which the power resource
  89  *     is desired to be.
  90  */
  91 PowerManager.prototype.request = function() {
  92     var args = validator_.validateMethod(arguments, [
  93         {
  94             name: 'resource',
  95             type: types_.ENUM,
  96             values: T_.getValues(PowerResource)
  97         },
  98         {
  99             name: 'state',
 100             type: types_.ENUM,
 101             values: T_.getValues(PowerState)
 102         }
 103     ]);
 104
 105     if (args.state === PowerScreenState.SCREEN_BRIGHT) {
 106         privUtils_.warn(
 107             'DEPRECATION WARNING: SCREEN_BRIGHT is deprecated and will be removed ' +
 108                 'from next release.'
 109         );
 110     }
 111
 112     if (
 113         (args.resource === PowerResource.SCREEN &&
 114             args.state === PowerCpuState.CPU_AWAKE) ||
 115         (args.resource === PowerResource.CPU && args.state !== PowerCpuState.CPU_AWAKE) ||
 116         (args.resource === PowerResource.SCREEN &&
 117             args.state === PowerScreenState.SCREEN_OFF)
 118     ) {
 119         throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
 120     }
 121
 122     var nativeParam = {
 123         resource: args.resource,
 124         state: args.state
 125     };
 126
 127     var ret = native_.callSync('PowerManager_request', nativeParam);
 128     if (native_.isFailure(ret)) {
 129         throw native_.getErrorObject(ret);
 130     }
 131 };
 132
 133 /**
 134  * Releases the power state request for the given resource.
 135  * @param {!PowerResource} resource The resource for which requests are to
 136  *     be removed.
 137  */
 138 PowerManager.prototype.release = function() {
 139     var args = validator_.validateMethod(arguments, [
 140         {
 141             name: 'resource',
 142             type: types_.ENUM,
 143             values: T_.getValues(PowerResource)
 144         }
 145     ]);
 146
 147     var nativeParam = {
 148         resource: args.resource
 149     };
 150
 151     var ret = native_.callSync('PowerManager_release', nativeParam);
 152     if (native_.isFailure(ret)) {
 153         throw native_.getErrorObject(ret);
 154     }
 155 };
 156
 157 /**
 158  * Sets the screen state change callback and monitors its state changes.
 159  * @param {!function} listener The screen state change callback.
 160  */
 161 PowerManager.prototype.setScreenStateChangeListener = function() {
 162     var args = validator_.validateArgs(arguments, [
 163         { name: 'listener', type: types_.FUNCTION }
 164     ]);
 165
 166     if (!screenStateChangeListener.isListenerSet()) {
 167         var ret = native_.callSync('PowerManager_setScreenStateChangeListener', {});
 168         if (native_.isFailure(ret)) {
 169             throw native_.getErrorObject(ret);
 170         }
 171     }
 172     screenStateChangeListener.addListener(args.listener);
 173 };
 174
 175 /**
 176  * Unsets the screen state change callback and stop monitoring it.
 177  */
 178 PowerManager.prototype.unsetScreenStateChangeListener = function() {
 179     if (screenStateChangeListener.isListenerSet()) {
 180         var ret = native_.callSync('PowerManager_unsetScreenStateChangeListener', {});
 181         if (native_.isFailure(ret)) {
 182             throw native_.getErrorObject(ret);
 183         }
 184     }
 185     screenStateChangeListener.removeListener();
 186 };
 187
 188 /**
 189  * Gets the screen brightness level of an application, from 0 to 1.
 190  * @return {number} Current screen brightness value.
 191  */
 192 PowerManager.prototype.getScreenBrightness = function() {
 193     var ret = native_.callSync('PowerManager_getScreenBrightness', {});
 194     if (native_.isFailure(ret)) {
 195         throw native_.getErrorObject(ret);
 196     } else {
 197         return native_.getResultObject(ret);
 198     }
 199 };
 200
 201 /**
 202  * Sets the screen brightness level for an application, from 0 to 1.
 203  * @param {!number} brightness The screen brightness value to set.
 204  */
 205 PowerManager.prototype.setScreenBrightness = function() {
 206     var args = validator_.validateArgs(arguments, [
 207         { name: 'brightness', type: types_.DOUBLE }
 208     ]);
 209
 210     if (args.brightness < 0 || args.brightness > 1) {
 211         throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
 212     }
 213
 214     var ret = native_.callSync('PowerManager_setScreenBrightness', {
 215         brightness: args.brightness
 216     });
 217     if (native_.isFailure(ret)) {
 218         throw native_.getErrorObject(ret);
 219     }
 220 };
 221
 222 /**
 223  * Returns true if the screen is on.
 224  * @return {boolean} true if screen is on.
 225  */
 226 PowerManager.prototype.isScreenOn = function() {
 227     var ret = native_.callSync('PowerManager_isScreenOn', {});
 228     if (native_.isFailure(ret)) {
 229         throw native_.getErrorObject(ret);
 230     } else {
 231         return native_.getResultObject(ret);
 232     }
 233 };
 234
 235 /**
 236  * Restores the screen brightness to the system default setting value.
 237  */
 238 PowerManager.prototype.restoreScreenBrightness = function() {
 239     var ret = native_.callSync('PowerManager_restoreScreenBrightness', {});
 240     if (native_.isFailure(ret)) {
 241         throw native_.getErrorObject(ret);
 242     }
 243 };
 244
 245 /**
 246  * Turns the screen on.
 247  */
 248 PowerManager.prototype.turnScreenOn = function() {
 249     privUtils_.warn(
 250         'DEPRECATION WARNING: turnScreenOn() is deprecated and will be removed from ' +
 251             'next release. Use request() instead.'
 252     );
 253
 254     var ret = native_.callSync('PowerManager_turnScreenOn', {});
 255     if (native_.isFailure(ret)) {
 256         throw native_.getErrorObject(ret);
 257     }
 258 };
 259
 260 /**
 261  * Turns the screen off.
 262  */
 263 PowerManager.prototype.turnScreenOff = function() {
 264     privUtils_.warn(
 265         'DEPRECATION WARNING: turnScreenOff() is deprecated and will be removed from ' +
 266             'next release. Use release() instead.'
 267     );
 268
 269     var ret = native_.callSync('PowerManager_turnScreenOff', {});
 270     if (native_.isFailure(ret)) {
 271         throw native_.getErrorObject(ret);
 272     }
 273 };
 274
 275 exports = new PowerManager();