Home | History | Annotate | Download | only in os 
      1 /*
      2  * Copyright (C) 2014 The Android Open Source Project
      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 package android.os;
     18 
     19 import android.view.Display;
     20 
     21 /**
     22  * Power manager local system service interface.
     23  *
     24  * @hide Only for use within the system server.
     25  */
     26 public abstract class PowerManagerInternal {
     27     /**
     28      * Wakefulness: The device is asleep.  It can only be awoken by a call to wakeUp().
     29      * The screen should be off or in the process of being turned off by the display controller.
     30      * The device typically passes through the dozing state first.
     31      */
     32     public static final int WAKEFULNESS_ASLEEP = 0;
     33 
     34     /**
     35      * Wakefulness: The device is fully awake.  It can be put to sleep by a call to goToSleep().
     36      * When the user activity timeout expires, the device may start dreaming or go to sleep.
     37      */
     38     public static final int WAKEFULNESS_AWAKE = 1;
     39 
     40     /**
     41      * Wakefulness: The device is dreaming.  It can be awoken by a call to wakeUp(),
     42      * which ends the dream.  The device goes to sleep when goToSleep() is called, when
     43      * the dream ends or when unplugged.
     44      * User activity may brighten the screen but does not end the dream.
     45      */
     46     public static final int WAKEFULNESS_DREAMING = 2;
     47 
     48     /**
     49      * Wakefulness: The device is dozing.  It is almost asleep but is allowing a special
     50      * low-power "doze" dream to run which keeps the display on but lets the application
     51      * processor be suspended.  It can be awoken by a call to wakeUp() which ends the dream.
     52      * The device fully goes to sleep if the dream cannot be started or ends on its own.
     53      */
     54     public static final int WAKEFULNESS_DOZING = 3;
     55 
     56 
     57     /**
     58      * Power hint:
     59      * Interaction: The user is interacting with the device. The corresponding data field must be
     60      * the expected duration of the interaction, or 0 if unknown.
     61      *
     62      * Sustained Performance Mode: The corresponding data field must be Enable/Disable
     63      * Sustained Performance Mode.
     64      *
     65      * Launch: This is specific for activity launching. The corresponding data field must be
     66      * the expected duration of the required boost, or 0 if unknown.
     67      *
     68      * These must be kept in sync with the values in hardware/libhardware/include/hardware/power.h
     69      */
     70     public static final int POWER_HINT_INTERACTION = 2;
     71     public static final int POWER_HINT_SUSTAINED_PERFORMANCE_MODE = 6;
     72     public static final int POWER_HINT_LAUNCH = 8;
     73 
     74     public static String wakefulnessToString(int wakefulness) {
     75         switch (wakefulness) {
     76             case WAKEFULNESS_ASLEEP:
     77                 return "Asleep";
     78             case WAKEFULNESS_AWAKE:
     79                 return "Awake";
     80             case WAKEFULNESS_DREAMING:
     81                 return "Dreaming";
     82             case WAKEFULNESS_DOZING:
     83                 return "Dozing";
     84             default:
     85                 return Integer.toString(wakefulness);
     86         }
     87     }
     88 
     89     /**
     90      * Returns true if the wakefulness state represents an interactive state
     91      * as defined by {@link android.os.PowerManager#isInteractive}.
     92      */
     93     public static boolean isInteractive(int wakefulness) {
     94         return wakefulness == WAKEFULNESS_AWAKE || wakefulness == WAKEFULNESS_DREAMING;
     95     }
     96 
     97     /**
     98      * Used by the window manager to override the screen brightness based on the
     99      * current foreground activity.
    100      *
    101      * This method must only be called by the window manager.
    102      *
    103      * @param brightness The overridden brightness, or -1 to disable the override.
    104      */
    105     public abstract void setScreenBrightnessOverrideFromWindowManager(int brightness);
    106 
    107     /**
    108      * Used by the window manager to override the button brightness based on the
    109      * current foreground activity.
    110      *
    111      * This method must only be called by the window manager.
    112      *
    113      * @param brightness The overridden brightness, or -1 to disable the override.
    114      */
    115     public abstract void setButtonBrightnessOverrideFromWindowManager(int brightness);
    116 
    117     /**
    118      * Used by the window manager to override the user activity timeout based on the
    119      * current foreground activity.  It can only be used to make the timeout shorter
    120      * than usual, not longer.
    121      *
    122      * This method must only be called by the window manager.
    123      *
    124      * @param timeoutMillis The overridden timeout, or -1 to disable the override.
    125      */
    126     public abstract void setUserActivityTimeoutOverrideFromWindowManager(long timeoutMillis);
    127 
    128     /**
    129      * Used by the window manager to tell the power manager that the user is no longer actively
    130      * using the device.
    131      */
    132     public abstract void setUserInactiveOverrideFromWindowManager();
    133 
    134     /**
    135      * Used by device administration to set the maximum screen off timeout.
    136      *
    137      * This method must only be called by the device administration policy manager.
    138      */
    139     public abstract void setMaximumScreenOffTimeoutFromDeviceAdmin(int timeMs);
    140 
    141     /**
    142      * Used by the dream manager to override certain properties while dozing.
    143      *
    144      * @param screenState The overridden screen state, or {@link Display#STATE_UNKNOWN}
    145      * to disable the override.
    146      * @param screenBrightness The overridden screen brightness, or
    147      * {@link PowerManager#BRIGHTNESS_DEFAULT} to disable the override.
    148      */
    149     public abstract void setDozeOverrideFromDreamManager(
    150             int screenState, int screenBrightness);
    151 
    152     public abstract boolean getLowPowerModeEnabled();
    153 
    154     public abstract void registerLowPowerModeObserver(LowPowerModeListener listener);
    155 
    156     public interface LowPowerModeListener {
    157         public void onLowPowerModeChanged(boolean enabled);
    158     }
    159 
    160     public abstract boolean setDeviceIdleMode(boolean enabled);
    161 
    162     public abstract boolean setLightDeviceIdleMode(boolean enabled);
    163 
    164     public abstract void setDeviceIdleWhitelist(int[] appids);
    165 
    166     public abstract void setDeviceIdleTempWhitelist(int[] appids);
    167 
    168     public abstract void updateUidProcState(int uid, int procState);
    169 
    170     public abstract void uidGone(int uid);
    171 
    172     public abstract void powerHint(int hintId, int data);
    173 }
    174