powerd.c

Android 一些工具

        case 'q':
            verbose = 0;
            break;
        case 'l':
            lcd_light_time = atoi(optarg);
            break;
        case 'k':
            key_light_time = atoi(optarg);
            break;
        case '?':
            fprintf(stderr, "%s: invalid option -%c\n",
                argv[0], optopt);
            exit(1);
        }
    } while (1);
    if(optind  != argc) {
        fprintf(stderr,"%s [-e eventdev]\n", argv[0]);
        return 1;
    }

    eventfd = open(eventdev, O_RDWR | O_NONBLOCK);
    if(eventfd < 0) {
        fprintf(stderr, "could not open %s, %s\n", eventdev, strerror(errno));
        return 1;
    }
    if(key_light_time >= lcd_light_time) {
        lcd_light_time = key_light_time + 1;
        fprintf(stderr,"lcd bright backlight time must be longer than keyboard backlight time.\n"
            "Setting lcd bright backlight time to %ld seconds\n", lcd_light_time);
    }

    user_activity_fd = open(android_user_activity_dev, O_RDWR);
    if(user_activity_fd >= 0) {
        int auto_off_fd = open(android_autooff_dev, O_RDWR);
        write(auto_off_fd, idle_time_string, strlen(idle_time_string));
        close(auto_off_fd);
    }

    powerfd = open(android_sleepdev, O_RDWR);
    if(powerfd >= 0) {
        powerfd_is_sleep = 1;
        if(verbose > 0)
            printf("Using android sleep dev: %s\n", android_sleepdev);
    }
    else {
        powerfd_is_sleep = 0;
        powerfd = open(powerdev, O_RDWR);
        if(powerfd >= 0) {
            if(verbose > 0)
                printf("Using linux power dev: %s\n", powerdev);
        }
    }
    if(powerfd < 0) {
        fprintf(stderr, "could not open %s, %s\n", powerdev, strerror(errno));
        return 1;
    }

    notifyfd = inotify_init();
    if(notifyfd < 0) {
        fprintf(stderr, "inotify_init failed, %s\n", strerror(errno));
        return 1;
    }
    fcntl(notifyfd, F_SETFL, O_NONBLOCK | fcntl(notifyfd, F_GETFL));
    for(i = 0; i < ARRAY_SIZE(watched_files); i++) {
        watched_files[i].id = inotify_add_watch(notifyfd, watched_files[i].filename, IN_MODIFY);
        printf("Watching %s, id %d\n", watched_files[i].filename, watched_files[i].id);
    }

    acquire_partial_wake_lock_fd = open(android_acquire_partial_wake_lock_dev, O_RDWR);
    acquire_full_wake_lock_fd = open(android_acquire_full_wake_lock_dev, O_RDWR);
    release_wake_lock_fd = open(android_release_wake_lock_dev, O_RDWR);

    if(user_activity_fd >= 0) {
        idle_time = 60*60*24; // driver handles real timeout
    }
    if(gotkey) {
        tv.tv_sec = idle_time;
        tv.tv_usec = 0;
    }
    else {
        tv.tv_sec = 0;
        tv.tv_usec = 500000;
    }
    
    while(1) {
        FD_ZERO(&rfds);
        //FD_SET(0, &rfds);
        FD_SET(eventfd, &rfds);
        FD_SET(notifyfd, &rfds);
        res = select(((notifyfd > eventfd) ? notifyfd : eventfd) + 1, &rfds, NULL, NULL, &tv);
        if(res < 0) {
            fprintf(stderr, "select failed, %s\n", strerror(errno));
            return 1;
        }
        if(res == 0) {
            if(light_event2.value == 1)
                goto light2_off;
            if(light_event.value == 1)
                goto light_off;
            if(user_activity_fd < 0) {
                if(gotkey && verbose > 0)
                    printf("Idle - sleep\n");
                if(!gotkey && verbose > 1)
                    printf("Reenter sleep\n");
                goto sleep;
            }
            else {
                tv.tv_sec = 60*60*24;
                tv.tv_usec = 0;
            }
        }
        if(res > 0) {
            //if(FD_ISSET(0, &rfds)) {
            //  printf("goto data on stdin quit\n");
            //  return 0;
            //}
            if(FD_ISSET(notifyfd, &rfds)) {
                write(acquire_partial_wake_lock_fd, wakelockstring, sizeof(wakelockstring) - 1);
                if(handle_inotify_event(notifyfd) > 0) {
                    write(acquire_full_wake_lock_fd, wakelockstring, sizeof(wakelockstring) - 1);
                }
                write(release_wake_lock_fd, wakelockstring, sizeof(wakelockstring) - 1);
            }
            if(FD_ISSET(eventfd, &rfds)) {
                write(acquire_partial_wake_lock_fd, wakelockstring, sizeof(wakelockstring) - 1);
                res = read(eventfd, &event, sizeof(event));
                if(res < (int)sizeof(event)) {
                    fprintf(stderr, "could not get event\n");
                    write(release_wake_lock_fd, wakelockstring, sizeof(wakelockstring) - 1);
                    return 1;
                }
                if(event.type == EV_PWR && event.code == KEY_SLEEP) {
                    event_sleep = event.value;
                }
                if(event.type == EV_KEY || (event.type == EV_SW && event.code == SW_0 && event.value == 1)) {
                    gotkey = 1;
                    if(user_activity_fd >= 0) {
                        char buf[32];
                        int len;
                        len = sprintf(buf, "%ld%06lu000", event.time.tv_sec, event.time.tv_usec);
                        write(user_activity_fd, buf, len);
                    }
                    if(lcd_light_time | key_light_time) {
                        tv.tv_sec = key_light_time;
                        light_event.value = 1;
                        write(eventfd, &light_event, sizeof(light_event));
                        light_event2.value = 1;
                        write(eventfd, &light_event2, sizeof(light_event2));
                    }
                    else {
                        tv.tv_sec = idle_time;
                    }
                    tv.tv_usec = 0;
                    if(verbose > 1)
                        printf("got %s %s %d%s\n", event.type == EV_KEY ? "key" : "switch", event.value ? "down" : "up", event.code, event_sleep ? " from sleep" : "");
                    if(event.code == KEY_POWER) {
                        if(event.value == 0) {
                            int tmp_got_power_key_down = got_power_key_down;
                            got_power_key_down = 0;
                            if(tmp_got_power_key_down) {
                                // power key released
                                if(verbose > 0)
                                    printf("Power key released - sleep\n");
                                write(release_wake_lock_fd, wakelockstring, sizeof(wakelockstring) - 1);
                                goto sleep;
                            }
                        }
                        else if(event_sleep == 0) {
                            got_power_key_down = 1;
                            power_key_down_time = event.time;
                        }
                    }
                }
                if(event.type == EV_SW && event.code == SW_0 && event.value == 0) {
                    if(verbose > 0)
                        printf("Flip closed - sleep\n");
                    power_key_down_time = event.time;
                    write(release_wake_lock_fd, wakelockstring, sizeof(wakelockstring) - 1);
                    goto sleep;
                }
                write(release_wake_lock_fd, wakelockstring, sizeof(wakelockstring) - 1);
            }
        }
        if(0) {
light_off:
            light_event.value = 0;
            write(eventfd, &light_event, sizeof(light_event));
            tv.tv_sec = idle_time - lcd_light_time;
        }
        if(0) {
light2_off:
            light_event2.value = 0;
            write(eventfd, &light_event2, sizeof(light_event2));
            tv.tv_sec = lcd_light_time - key_light_time;
        }
        if(0) {
sleep:
            if(light_event.value == 1) {
                light_event.value = 0;
                write(eventfd, &light_event, sizeof(light_event));
                light_event2.value = 0;
                write(eventfd, &light_event2, sizeof(light_event2));
                tv.tv_sec = idle_time - lcd_light_time;
            }
            if(powerfd_is_sleep) {
                char buf[32];
                int len;
                len = sprintf(buf, "%ld%06lu000", power_key_down_time.tv_sec, power_key_down_time.tv_usec);
                write(powerfd, buf, len);
            }
            else
                write(powerfd, suspendstring, sizeof(suspendstring) - 1);
            gotkey = 0;
            tv.tv_sec = 0;
            tv.tv_usec = 500000;
        }
    }

    return 0;
}