tequilaOS/platform_hardware_libhardware_legacy
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "libpower: acquire wake locks from SystemSuspend service."

Browse source
This commit is contained in:
Tri Vo 2018-10-09 23:52:06 +00:00 committed by Gerrit Code Review
commit aa8f6d2a2d
3 changed files with 78 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
Android.bp
View file

@ -1,9 +1,5 @@
// Copyright 2006 The Android Open Source Project
subdirs = [
"audio",
]
cc_library_headers {
name: "libhardware_legacy_headers",
vendor_available: true,
@ -15,11 +11,10 @@ cc_library_headers {
cc_library {
name: "libpower",
srcs: ["power.c"],
cflags: ["-Wall", "-Werror"],
defaults: ["system_suspend_defaults"],
srcs: ["power.cpp"],
export_include_dirs: ["include"],
shared_libs: ["libcutils", "liblog"],
shared_libs: ["android.system.suspend@1.0"],
vendor_available: true,
vndk: {
enabled: true,
@ -28,16 +23,15 @@ cc_library {
cc_library_shared {
name: "libhardware_legacy",
defaults: ["system_suspend_defaults"],
vendor_available: true,
vndk: {
enabled: true,
},
shared_libs: [
"libbase",
"android.system.suspend@1.0",
"libdl",
"libcutils",
"liblog",
],
header_libs: [
@ -51,12 +45,10 @@ cc_library_shared {
"-DQEMU_HARDWARE",
"-Wall",
"-Werror",
"-Wno-unused-parameter",
"-Wno-gnu-designator",
],
srcs: [
"power.c",
"power.cpp",
"uevent.c",
],
}

124
power.c
View file

@ -1,124 +0,0 @@
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <hardware_legacy/power.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pthread.h>
#define LOG_TAG "power"
#include <log/log.h>
enum {
ACQUIRE_PARTIAL_WAKE_LOCK = 0,
RELEASE_WAKE_LOCK,
OUR_FD_COUNT
};
const char * const OLD_PATHS[] = {
"/sys/android_power/acquire_partial_wake_lock",
"/sys/android_power/release_wake_lock",
};
const char * const NEW_PATHS[] = {
"/sys/power/wake_lock",
"/sys/power/wake_unlock",
};
//XXX static pthread_once_t g_initialized = THREAD_ONCE_INIT;
static int g_initialized = 0;
static int g_fds[OUR_FD_COUNT];
static int g_error = -1;
static int
open_file_descriptors(const char * const paths[])
{
int i;
for (i=0; i<OUR_FD_COUNT; i++) {
int fd = open(paths[i], O_RDWR | O_CLOEXEC);
if (fd < 0) {
g_error = -errno;
ALOGE("fatal error opening \"%s\": %s\n", paths[i],
strerror(errno));
return -1;
}
g_fds[i] = fd;
}
g_error = 0;
return 0;
}
static inline void
initialize_fds(void)
{
// XXX: should be this:
//pthread_once(&g_initialized, open_file_descriptors);
// XXX: not this:
if (g_initialized == 0) {
if(open_file_descriptors(NEW_PATHS) < 0)
open_file_descriptors(OLD_PATHS);
g_initialized = 1;
}
}
int
acquire_wake_lock(int lock, const char* id)
{
initialize_fds();
// ALOGI("acquire_wake_lock lock=%d id='%s'\n", lock, id);
if (g_error) return g_error;
int fd;
ssize_t ret;
if (lock != PARTIAL_WAKE_LOCK) {
return -EINVAL;
}
fd = g_fds[ACQUIRE_PARTIAL_WAKE_LOCK];
ret = write(fd, id, strlen(id));
if (ret < 0) {
return -errno;
}
return ret;
}
int
release_wake_lock(const char* id)
{
initialize_fds();
// ALOGI("release_wake_lock id='%s'\n", id);
if (g_error) return g_error;
ssize_t len = write(g_fds[RELEASE_WAKE_LOCK], id, strlen(id));
if (len < 0) {
return -errno;
}
return len;
}

72
power.cpp Normal file
View file

@ -0,0 +1,72 @@
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "power"
#define ATRACE_TAG ATRACE_TAG_POWER
#include <android-base/logging.h>
#include <android/system/suspend/1.0/ISystemSuspend.h>
#include <hardware_legacy/power.h>
#include <utils/Trace.h>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>
using android::sp;
using android::system::suspend::V1_0::ISystemSuspend;
using android::system::suspend::V1_0::IWakeLock;
using android::system::suspend::V1_0::WakeLockType;
static std::mutex gLock;
static std::unordered_map<std::string, sp<IWakeLock>> gWakeLockMap;
static sp<ISystemSuspend> getSystemSuspendServiceOnce() {
static std::once_flag initFlag;
static sp<ISystemSuspend> suspendService = nullptr;
std::call_once(initFlag, []() {
// It's possible for the calling process to not have permissions to
// ISystemSuspend. getService will then return nullptr.
suspendService = ISystemSuspend::getService();
});
return suspendService;
}
int acquire_wake_lock(int, const char* id) {
ATRACE_CALL();
sp<ISystemSuspend> suspendService = getSystemSuspendServiceOnce();
if (!suspendService) {
return -1;
}
std::lock_guard<std::mutex> l{gLock};
if (!gWakeLockMap[id]) {
gWakeLockMap[id] = suspendService->acquireWakeLock(WakeLockType::PARTIAL, id);
}
return 0;
}
int release_wake_lock(const char* id) {
ATRACE_CALL();
std::lock_guard<std::mutex> l{gLock};
if (gWakeLockMap[id]) {
gWakeLockMap[id]->release();
gWakeLockMap[id] = nullptr;
return 0;
}
return -1;
}