163 lines
2.8 KiB
C++
163 lines
2.8 KiB
C++
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <pthread.h>
|
|
#include "eq_log.h"
|
|
#include "Rk_wake_lock.h"
|
|
|
|
struct rk_wake_lock {
|
|
char *id;
|
|
};
|
|
|
|
#define TAG "WAKE_LOCK"
|
|
|
|
#define debug(fmt, args...) \
|
|
eq_debug(TAG "[%s] " fmt "\n", __func__, ##args)
|
|
|
|
enum {
|
|
ACQUIRE_PARTIAL_WAKE_LOCK = 0,
|
|
RELEASE_WAKE_LOCK,
|
|
OUR_FD_COUNT
|
|
};
|
|
|
|
const char * const WAKE_LOCK_PATHS[] = {
|
|
"/sys/power/wake_lock",
|
|
"/sys/power/wake_unlock",
|
|
};
|
|
|
|
static int g_initialized = 0;
|
|
static int g_fds[2];
|
|
static int g_error = -1;
|
|
|
|
static int open_file_descriptors(const char * const paths[])
|
|
{
|
|
for (int i = 0 ; i < 2; i++) {
|
|
int fd = open(paths[i], O_RDWR | O_CLOEXEC);
|
|
if (fd < 0) {
|
|
g_error = -errno;
|
|
debug("fatal error opening \"%s\": %s", paths[i],
|
|
strerror(errno));
|
|
return -1;
|
|
}
|
|
g_fds[i] = fd;
|
|
}
|
|
|
|
g_error = 0;
|
|
return 0;
|
|
}
|
|
|
|
static inline void initialize_fds(void) {
|
|
if (g_initialized == 0) {
|
|
open_file_descriptors(WAKE_LOCK_PATHS);
|
|
g_initialized = 1;
|
|
}
|
|
}
|
|
|
|
struct rk_wake_lock* RK_wake_lock_new(const char *id) {
|
|
struct rk_wake_lock* lock;
|
|
if (!id)
|
|
return NULL;
|
|
initialize_fds();
|
|
|
|
lock = (struct rk_wake_lock*)malloc(sizeof(struct rk_wake_lock));
|
|
lock->id = strdup(id);
|
|
return lock;
|
|
}
|
|
|
|
void RK_wake_lock_delete(struct rk_wake_lock* lock) {
|
|
if (lock && lock->id)
|
|
free(lock->id);
|
|
if (lock)
|
|
free(lock);
|
|
}
|
|
|
|
int RK_acquire_wake_lock(struct rk_wake_lock *wake_lock) {
|
|
char *id = wake_lock->id;
|
|
debug("id=%s", id);
|
|
|
|
if (g_error)
|
|
return g_error;
|
|
|
|
int fd;
|
|
size_t len;
|
|
ssize_t ret;
|
|
|
|
fd = g_fds[0];
|
|
|
|
ret = write(fd, id, strlen(id));
|
|
if (ret < 0) {
|
|
return -errno;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int RK_release_wake_lock(struct rk_wake_lock *wake_lock) {
|
|
char *id = wake_lock->id;
|
|
int fd;
|
|
|
|
debug("id=%s", id);
|
|
|
|
if (g_error)
|
|
return g_error;
|
|
|
|
fd = g_fds[1];
|
|
|
|
ssize_t len = write(fd, id, strlen(id));
|
|
if (len < 0) {
|
|
return -errno;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
static int exec(const char *cmd, char *buf, const size_t size) {
|
|
FILE *stream = NULL;
|
|
char tmp[1024];
|
|
|
|
if ((stream = popen(cmd,"r")) == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
if (buf == NULL) {
|
|
pclose(stream);
|
|
return -2;
|
|
}
|
|
|
|
buf[0] = '\0';
|
|
while (fgets(tmp, sizeof(tmp) -1, stream)) {
|
|
if (strlen(buf) + strlen(tmp) >= size) {
|
|
pclose(stream);
|
|
return -3;
|
|
}
|
|
strcat(buf, tmp);
|
|
}
|
|
pclose(stream);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int RK_wait_all_wake_lock_release(int timeout_ms) {
|
|
int cnt = timeout_ms / 10;
|
|
char result[1024];
|
|
|
|
while(cnt--) {
|
|
memset(result, 0, 1024);
|
|
exec("cat /sys/power/wake_lock", result, 1024);
|
|
if (strlen(result) <= 1) //换行符
|
|
break;
|
|
usleep(10*1000);
|
|
debug("## suspend waiting wake_lock: %s", result);
|
|
}
|
|
if (cnt == 0) {
|
|
debug("wait suspend timeout, abort suspend");
|
|
debug("unreleased wake_lock: %s", result);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|