esdk/layers/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/main.c

/* //device/system/rild/rild.c
**
** Copyright 2006 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 <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <dlfcn.h>
#include <string.h>
#include <pthread.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <log/log.h>
#include <liblog/lynq_deflog.h>
#include <include/lynq_uci.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <signal.h>


#define LOG_UCI_MODULE "lynq_autosuspend"
#define LOG_UCI_FILE "lynq_uci"

#define LOG_TAG "AUTOSUSPEND"

#define USER_LOG_TAG "PMS"

#define SOCK_PATH  "/tmp/autosuspend.cmd.server"  //不能在当前这个目录创建socket文件，否则报错找不到文件(可能是因为这是在共享文件夹下，不支持创建socket文件)

#define SOCK_DATA_PATH  "/tmp/autosuspend.data.server"

// #define LYINFLOG(X...)  lynq_log_global_output(LOG_INFO,X)

#define TIME_OUT_TIME 30


#define MAX_LIB_ARGS        16

int adb_debug_mode = 0;


pthread_cond_t feedback_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t feedback_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t time_info_mutex = PTHREAD_MUTEX_INITIALIZER;

extern int autosuspend_enable(void);
extern int autosuspend_disable(void);
extern void init_wakelock_func(void);
extern void init_sim_func();
extern void init_network_func();
extern void set_wakeup_callback(void (*func)(bool success));
extern void wakeup_feedback(bool success);
extern int (*lynq_screen)(int num);

struct time_info_t
{
    long sleep_start_time;
    long wakeup_time;
};

struct time_info_t time_info; 

static void usage(const char *argv0) {
    fprintf(stderr, "Usage: %s -l <possible_max_sleep_time> [-- <args for Autosuspend Service>]\n", argv0);
    exit(EXIT_FAILURE);
}



static int make_argv(char * args, char ** argv) {
    // Note: reserve argv[0]
    int count = 1;
    char * tok;
    char * s = args;

    while ((tok = strtok(s, " \0"))) {
        argv[count] = tok;
        s = NULL;
        count++;
    }
    return count;
}

static int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
    int n;

    while((n = accept(fd, sa, salenptr)) < 0)
    {
        if((errno == ECONNABORTED) || (errno == EINTR))
            continue;
        else
        {
            ALOGI("accept error\n");
            return -1;
        }
    }
    return n;
}

static int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    if(bind(fd, sa, salen) < 0)
    {
        // ALOGI("bind error\n");
        perror("bind error");
        return -1;
    }
	return 0;
}


static int Socket(int family, int type, int protocol)
{
    int n;

    if ( (n = socket(family, type, protocol)) < 0)
    {
        ALOGI("socket error\n");
        return -1;
    }
    return n;
}

static int Listen(int fd, int backlog)
{
    if(listen(fd, backlog) < 0)
    {
        ALOGI("listen error\n");
        return -1;
    }
	return 0;
}


static int listen_port(struct sockaddr_un *addr, char *sockpath)
{
    int listenfd;
    listenfd = Socket(AF_UNIX,SOCK_STREAM,0);
    if(listenfd == -1)
        return -1;
    memset(addr, 0, sizeof(struct sockaddr_un));
    addr->sun_family = AF_UNIX;
    strcpy(addr->sun_path,sockpath);
    // int opt = 1;
	// if(setsockopt(listenfd, SOL_SOCKET,SO_REUSEADDR, (const void *)&opt, sizeof(opt)) == -1)
    // {
    //     perror("setsockopt error");
    //     return -1;
    // }

// 以上方法对非网络的本地socket无效，应该用unlink函数避免Address already in use的错误


    unlink(sockpath);
    if(Bind(listenfd,(struct sockaddr *)addr,sizeof(*addr)) == -1)
        return -1;

    if(Listen(listenfd,20) == -1)
        return -1;

    return listenfd; 
}

static ssize_t Read(int fd, void *ptr, size_t nbytes)
{
    ssize_t n;
    
    while((n = read(fd, ptr, nbytes)) == -1)
    {
       //printf("READ,%d\n",fd);
        if (errno == EINTR)
		{	
			ALOGI("read error eintr\n");
            continue;
		}
        else if(errno == EAGAIN || errno == EWOULDBLOCK)
        {
            ALOGI("read time out\n");
            return -1;
        }
        else
        {
            ALOGI("read error\n");
            return -1;
        }
    }
    //sleep(2);
    //printf("READ1,%d\n", fd);
    return n;
}

static ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
    ssize_t n;

    while((n = write(fd, ptr, nbytes)) == -1)
    {
        if (errno == EINTR)
            continue;
        else if(errno == EPIPE)
		{
			ALOGI("write error epipe\n");
			return -1;
		}  
		else
			return -1;
    }
    return n;
}

static int Close(int fd)
{
    if (close(fd) == -1)
    {
        ALOGI("close error\n");
        return -1;
    }
	return 0;
}


void *deal_autosuspend(void *sockfd)
{
    int commfd = *((int *)sockfd);
    char buf[20];
    char res[15];

    while(1)
    {
        memset(buf,0,sizeof(buf));
        ALOGI("deal_autosuspend start to read.\n");
        // 错误点：read函数在对端关闭后，也会直接返回0,不会阻塞，因此要判断是否返回0,返回0表示对端已经关闭，此时要跳出while循环不再监听
        // 为什么对端会关闭？因为在客户端没有用nohup方式打开的情况下，系统睡眠后客户端进行会直接被杀死，对端会关闭，所以会导致read不阻塞，且总是返回0的现象
        if(Read(commfd,buf,sizeof(buf)) <= 0) 
        {
            ALOGI("service receive suspend_cmd fail or client is closed.\n");
            Close(commfd);
            break;
        }
        if(strcmp(buf,"enable") == 0)
        {
            if(autosuspend_enable() < 0)
            {
                ALOGI("autosuspend_enable fail.\n");
            }
            else
            {
                ALOGI("autosuspend_enable success.\n");
            }        
        }
        else if(strcmp(buf,"disable") == 0)
        {
            if(autosuspend_disable() < 0)
            {
                ALOGI("autosuspend_disable fail.\n");
            }
            else
            {
                ALOGI("autosuspend_disable success.\n");

            }        
        }

        else
        {
            ALOGI("Unknown cmd : %s\n",buf);
        }

    }



}

#ifdef GSW_SUSPEND_CFG
/*jb.qi add for service send when DTR is low on 20221111 start */
void *dtr_wakeup()
{
    FILE *fp;
    int ret;
    bool success = true;
    char buf[30];
    char dtr_buffer[25];
    RLOGD("dtr_wakeup start\n");
    while(1)
    {
        fp = popen("cat /sys/devices/platform/10005000.pinctrl/mt_gpio |grep 006:","r");
        fgets(dtr_buffer, sizeof(dtr_buffer), fp);
        if(dtr_buffer[7] == '0')
        {
            time_info.sleep_start_time = 123;
            time_info.wakeup_time = 123;
            if (pthread_cond_broadcast(&feedback_cond) != 0) 
            {
                strerror_r(errno, buf, sizeof(buf));
                ALOGI("Error broadcast cond: %s\n", buf);
            }   
            RLOGD("dtr_wakeup success!\n");
            sleep(3);
        }
        usleep(500);
        pclose(fp);
    }
}
/*jb.qi add for service send when DTR is low on 20221111 end */
#endif

void *send_feedback(void *sockfd)
{
    int commfd = *((int *)sockfd);
    char buf[80];

    while (1)
    {
        memset(buf,0,sizeof(buf));
        ALOGI("send_feedback thread wait to send.\n");
        pthread_mutex_lock(&feedback_mutex);
        pthread_cond_wait(&feedback_cond,&feedback_mutex);

        ALOGI("send_feedback thread is now sending the feedback to client.\n");
        pthread_mutex_lock(&time_info_mutex);
        if(Write(commfd,&time_info,sizeof(struct time_info_t)) <= 0) 
        {
            ALOGI("service send wakeup_feedback struct fail.\n");
            Close(commfd);
            pthread_mutex_unlock(&time_info_mutex);
            pthread_mutex_unlock(&feedback_mutex);
#ifdef GSW_SUSPEND_CFG
            continue ;//jb.qi add for service send when DTR is low on 20221111 
#endif

#ifdef MOBILETEK_SUSPEND_CFG
            break ;
#endif
        }        
        pthread_mutex_unlock(&time_info_mutex);

        pthread_mutex_unlock(&feedback_mutex);



    }

}


int main(int argc, char **argv) {


    // int i = 0;
    // RLOGD("**Autosuspend Service Daemon Started**");
    // RLOGD("**Autosuspend Service param count=%d**", argc);
    char tmp[20];

    int commfd, commfd_data, server_sock, server_data_sock,len, len_data;

    struct sockaddr_un server_sockaddr;
    struct sockaddr_un server_data_sockaddr;
    struct sockaddr_un client_sockaddr;

    len = sizeof(server_sockaddr);


    pthread_t tid;
#ifdef GSW_SUSPEND_CFG
	pthread_t tid_1;//jb.qi add for service send when DTR is low on 20221111 
#endif
    
    LYLOGEINIT(USER_LOG_TAG);
    LYLOGSET(LOG_DEBUG);    
    // LYLOGSET(LOG_ERROR);

    int auto_enable = 0;

    lynq_get_value(LOG_UCI_FILE, LOG_UCI_MODULE, "debug", tmp); // 即获取系统层面的环境变量
    ALOGI("Autosuspend Service Daemon. debug %s\n",tmp);
    adb_debug_mode=atoi(tmp);
    lynq_get_value(LOG_UCI_FILE, LOG_UCI_MODULE, "auto_enable", tmp);
    auto_enable=atoi(tmp);
    ALOGI("Autosuspend Service Daemon. auto_enable %s\n",tmp);
#ifdef MOBILETEK_SUSPEND_CFG
    init_wakelock_func();
    init_sim_func();
#endif
    signal(SIGPIPE,SIG_IGN); // 忽略SIGPIPE信号，防止由于客户端关闭，继续往客户端write，会导致服务端收到SIGPIPE信号而Broken pipe

    
    // init_network_func();

    // if(pthread_cond_init(&feedback_cond,NULL) != 0)
    // {
    //     strerror_r(errno, buf, sizeof(buf));
    //     ALOGI("Error creating cond: %s\n", buf);
    //     return -1;
    // }

    set_wakeup_callback(wakeup_feedback);
    // 注册回调函数

   if(auto_enable==0)
   {
      if(autosuspend_disable() < 0)
     {
       ALOGI("autosuspend_disable fail.\n");
     }
     else
     {
       ALOGI("autosuspend_disable success.\n");
     }
   }
   if(auto_enable==1)
   {
      if(autosuspend_enable() < 0)
     {
       ALOGI("autosuspend_enable fail.\n");
     }
     else
     {
       ALOGI("autosuspend_enable success.\n");
     }
   }


    server_sock = listen_port(&server_sockaddr,SOCK_PATH);
    if(server_sock == -1)
        return -1;

    server_data_sock = listen_port(&server_data_sockaddr,SOCK_DATA_PATH);
    if(server_data_sock == -1)
        return -1;
#ifdef GSW_SUSPEND_CFG
    /*jb.qi add for service send when DTR is low on 20221111 start*/
    pthread_create(&tid_1,NULL,dtr_wakeup,NULL);
    pthread_detach(tid_1);
    /*jb.qi add for service send when DTR is low on 20221111 end*/
#endif

    while (1)
    {
        ALOGI("service socket listening...\n");
        commfd = Accept(server_sock,(struct sockaddr *)&client_sockaddr,&len);
        if(commfd == -1)
        {
            return -1;
        }
        if(getpeername(commfd, (struct sockaddr *)&client_sockaddr, &len) == -1)
        {
            ALOGI("GETPEERNAME ERROR.\n");
            // Close(server_sock);
            Close(commfd);
            continue;
        }
        else
        {
            ALOGI("Client socket filepath: %s\n", client_sockaddr.sun_path);
        }

        commfd_data = Accept(server_data_sock,NULL,NULL);
        if(commfd_data == -1)
        {
            return -1;
        }
        ALOGI("data channel connected.\n");
        
        pthread_create(&tid,NULL,deal_autosuspend,(void*)&commfd);//这里很容易错，最后一个参数要取地址，这是一个指针
        pthread_detach(tid);   

        pthread_create(&tid,NULL,send_feedback,(void*)&commfd_data);
        pthread_detach(tid); 


    }
    
 
}

DEFINE_LYNQ_LIB_LOG(LYNQ_AUTOSUSPEND)