services/jni/com_android_server_power_PowerManagerService.cpp

   1 /*
   2  * Copyright (C) 2010 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 #define LOG_TAG "PowerManagerService-JNI"
  18
  19 //#define LOG_NDEBUG 0
  20
  21 #include "JNIHelp.h"
  22 #include "jni.h"
  23
  24 #include <ScopedUtfChars.h>
  25
  26 #include <limits.h>
  27
  28 #include <android_runtime/AndroidRuntime.h>
  29 #include <utils/Timers.h>
  30 #include <utils/misc.h>
  31 #include <utils/String8.h>
  32 #include <utils/Log.h>
  33 #include <hardware/power.h>
  34 #include <hardware_legacy/power.h>
  35 #include <cutils/android_reboot.h>
  36 #include <suspend/autosuspend.h>
  37
  38 #include "com_android_server_power_PowerManagerService.h"
  39
  40 namespace android {
  41
  42 // ----------------------------------------------------------------------------
  43
  44 static struct {
  45     jmethodID wakeUpFromNative;
  46     jmethodID goToSleepFromNative;
  47     jmethodID userActivityFromNative;
  48 } gPowerManagerServiceClassInfo;
  49
  50 // ----------------------------------------------------------------------------
  51
  52 static jobject gPowerManagerServiceObj;
  53 static struct power_module* gPowerModule;
  54
  55 static Mutex gPowerManagerLock;
  56 static bool gScreenOn;
  57 static bool gScreenBright;
  58
  59 static nsecs_t gLastEventTime[USER_ACTIVITY_EVENT_LAST + 1];
  60
  61 // Throttling interval for user activity calls.
  62 static const nsecs_t MIN_TIME_BETWEEN_USERACTIVITIES = 500 * 1000000L; // 500ms
  63
  64 // ----------------------------------------------------------------------------
  65
  66 static bool checkAndClearExceptionFromCallback(JNIEnv* env, const char* methodName) {
  67     if (env->ExceptionCheck()) {
  68         ALOGE("An exception was thrown by callback '%s'.", methodName);
  69         LOGE_EX(env);
  70         env->ExceptionClear();
  71         return true;
  72     }
  73     return false;
  74 }
  75
  76 bool android_server_PowerManagerService_isScreenOn() {
  77     AutoMutex _l(gPowerManagerLock);
  78     return gScreenOn;
  79 }
  80
  81 bool android_server_PowerManagerService_isScreenBright() {
  82     AutoMutex _l(gPowerManagerLock);
  83     return gScreenBright;
  84 }
  85
  86 void android_server_PowerManagerService_userActivity(nsecs_t eventTime, int32_t eventType) {
  87     // Tell the power HAL when user activity occurs.
  88     if (gPowerModule && gPowerModule->powerHint) {
  89         gPowerModule->powerHint(gPowerModule, POWER_HINT_INTERACTION, NULL);
  90     }
  91
  92     if (gPowerManagerServiceObj) {
  93         // Throttle calls into user activity by event type.
  94         // We're a little conservative about argument checking here in case the caller
  95         // passes in bad data which could corrupt system state.
  96         if (eventType >= 0 && eventType <= USER_ACTIVITY_EVENT_LAST) {
  97             nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
  98             if (eventTime > now) {
  99                 eventTime = now;
 100             }
 101
 102             if (gLastEventTime[eventType] + MIN_TIME_BETWEEN_USERACTIVITIES > eventTime) {
 103                 return;
 104             }
 105             gLastEventTime[eventType] = eventTime;
 106         }
 107
 108         JNIEnv* env = AndroidRuntime::getJNIEnv();
 109
 110         env->CallVoidMethod(gPowerManagerServiceObj,
 111                 gPowerManagerServiceClassInfo.userActivityFromNative,
 112                 nanoseconds_to_milliseconds(eventTime), eventType, 0);
 113         checkAndClearExceptionFromCallback(env, "userActivityFromNative");
 114     }
 115 }
 116
 117 void android_server_PowerManagerService_wakeUp(nsecs_t eventTime) {
 118     if (gPowerManagerServiceObj) {
 119         JNIEnv* env = AndroidRuntime::getJNIEnv();
 120
 121         env->CallVoidMethod(gPowerManagerServiceObj,
 122                 gPowerManagerServiceClassInfo.wakeUpFromNative,
 123                 nanoseconds_to_milliseconds(eventTime));
 124         checkAndClearExceptionFromCallback(env, "wakeUpFromNative");
 125     }
 126 }
 127
 128 void android_server_PowerManagerService_goToSleep(nsecs_t eventTime) {
 129     if (gPowerManagerServiceObj) {
 130         JNIEnv* env = AndroidRuntime::getJNIEnv();
 131
 132         env->CallVoidMethod(gPowerManagerServiceObj,
 133                 gPowerManagerServiceClassInfo.goToSleepFromNative,
 134                 nanoseconds_to_milliseconds(eventTime), 0);
 135         checkAndClearExceptionFromCallback(env, "goToSleepFromNative");
 136     }
 137 }
 138
 139 // ----------------------------------------------------------------------------
 140
 141 static void nativeInit(JNIEnv* env, jobject obj) {
 142     gPowerManagerServiceObj = env->NewGlobalRef(obj);
 143
 144     status_t err = hw_get_module(POWER_HARDWARE_MODULE_ID,
 145             (hw_module_t const**)&gPowerModule);
 146     if (!err) {
 147         gPowerModule->init(gPowerModule);
 148     } else {
 149         ALOGE("Couldn't load %s module (%s)", POWER_HARDWARE_MODULE_ID, strerror(-err));
 150     }
 151 }
 152
 153 static void nativeSetPowerState(JNIEnv* env,
 154         jclass clazz, jboolean screenOn, jboolean screenBright) {
 155     AutoMutex _l(gPowerManagerLock);
 156     gScreenOn = screenOn;
 157     gScreenBright = screenBright;
 158 }
 159
 160 static void nativeAcquireSuspendBlocker(JNIEnv *env, jclass clazz, jstring nameStr) {
 161     ScopedUtfChars name(env, nameStr);
 162     acquire_wake_lock(PARTIAL_WAKE_LOCK, name.c_str());
 163 }
 164
 165 static void nativeReleaseSuspendBlocker(JNIEnv *env, jclass clazz, jstring nameStr) {
 166     ScopedUtfChars name(env, nameStr);
 167     release_wake_lock(name.c_str());
 168 }
 169
 170 static void nativeSetInteractive(JNIEnv *env, jclass clazz, jboolean enable) {
 171     if (gPowerModule) {
 172         if (enable) {
 173             ALOGD_IF_SLOW(20, "Excessive delay in setInteractive(true) while turning screen on");
 174             gPowerModule->setInteractive(gPowerModule, true);
 175         } else {
 176             ALOGD_IF_SLOW(20, "Excessive delay in setInteractive(false) while turning screen off");
 177             gPowerModule->setInteractive(gPowerModule, false);
 178         }
 179     }
 180 }
 181
 182 static void nativeSetAutoSuspend(JNIEnv *env, jclass clazz, jboolean enable) {
 183     if (enable) {
 184         ALOGD_IF_SLOW(100, "Excessive delay in autosuspend_enable() while turning screen off");
 185         autosuspend_enable();
 186     } else {
 187         ALOGD_IF_SLOW(100, "Excessive delay in autosuspend_disable() while turning screen on");
 188         autosuspend_disable();
 189     }
 190 }
 191
 192 static void nativeShutdown(JNIEnv *env, jclass clazz) {
 193     android_reboot(ANDROID_RB_POWEROFF, 0, 0);
 194 }
 195
 196 static void nativeReboot(JNIEnv *env, jclass clazz, jstring reason) {
 197     if (reason == NULL) {
 198         android_reboot(ANDROID_RB_RESTART, 0, 0);
 199     } else {
 200         const char *chars = env->GetStringUTFChars(reason, NULL);
 201         android_reboot(ANDROID_RB_RESTART2, 0, (char *) chars);
 202         env->ReleaseStringUTFChars(reason, chars);  // In case it fails.
 203     }
 204     jniThrowIOException(env, errno);
 205 }
 206
 207
 208 // ----------------------------------------------------------------------------
 209
 210 static JNINativeMethod gPowerManagerServiceMethods[] = {
 211     /* name, signature, funcPtr */
 212     { "nativeInit", "()V",
 213             (void*) nativeInit },
 214     { "nativeSetPowerState", "(ZZ)V",
 215             (void*) nativeSetPowerState },
 216     { "nativeAcquireSuspendBlocker", "(Ljava/lang/String;)V",
 217             (void*) nativeAcquireSuspendBlocker },
 218     { "nativeReleaseSuspendBlocker", "(Ljava/lang/String;)V",
 219             (void*) nativeReleaseSuspendBlocker },
 220     { "nativeSetInteractive", "(Z)V",
 221             (void*) nativeSetInteractive },
 222     { "nativeSetAutoSuspend", "(Z)V",
 223             (void*) nativeSetAutoSuspend },
 224     { "nativeShutdown", "()V",
 225             (void*) nativeShutdown },
 226     { "nativeReboot", "(Ljava/lang/String;)V",
 227             (void*) nativeReboot },
 228 };
 229
 230 #define FIND_CLASS(var, className) \
 231         var = env->FindClass(className); \
 232         LOG_FATAL_IF(! var, "Unable to find class " className);
 233
 234 #define GET_METHOD_ID(var, clazz, methodName, methodDescriptor) \
 235         var = env->GetMethodID(clazz, methodName, methodDescriptor); \
 236         LOG_FATAL_IF(! var, "Unable to find method " methodName);
 237
 238 #define GET_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
 239         var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
 240         LOG_FATAL_IF(! var, "Unable to find field " fieldName);
 241
 242 int register_android_server_PowerManagerService(JNIEnv* env) {
 243     int res = jniRegisterNativeMethods(env, "com/android/server/power/PowerManagerService",
 244             gPowerManagerServiceMethods, NELEM(gPowerManagerServiceMethods));
 245     LOG_FATAL_IF(res < 0, "Unable to register native methods.");
 246
 247     // Callbacks
 248
 249     jclass clazz;
 250     FIND_CLASS(clazz, "com/android/server/power/PowerManagerService");
 251
 252     GET_METHOD_ID(gPowerManagerServiceClassInfo.wakeUpFromNative, clazz,
 253             "wakeUpFromNative", "(J)V");
 254
 255     GET_METHOD_ID(gPowerManagerServiceClassInfo.goToSleepFromNative, clazz,
 256             "goToSleepFromNative", "(JI)V");
 257
 258     GET_METHOD_ID(gPowerManagerServiceClassInfo.userActivityFromNative, clazz,
 259             "userActivityFromNative", "(JII)V");
 260
 261     // Initialize
 262     for (int i = 0; i <= USER_ACTIVITY_EVENT_LAST; i++) {
 263         gLastEventTime[i] = LLONG_MIN;
 264     }
 265     gScreenOn = true;
 266     gScreenBright = true;
 267     gPowerManagerServiceObj = NULL;
 268     gPowerModule = NULL;
 269     return 0;
 270 }
 271
 272 } /* namespace android */