Home | History | Annotate | Download | only in slideshow 
      1 /*
      2  * Copyright (C) 2015 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 #include <unistd.h>
     18 #include <stdlib.h>
     19 #include <limits.h>
     20 #include <time.h>
     21 #include <linux/input.h>
     22 #include <cutils/klog.h>
     23 #include <utils/SystemClock.h>
     24 #include "minui/minui.h"
     25 
     26 #define NEXT_TIMEOUT_MS 5000
     27 #define LAST_TIMEOUT_MS 30000
     28 
     29 #define LOGE(x...) do { KLOG_ERROR("slideshow", x); } while (0)
     30 
     31 static int input_cb(int fd, unsigned int epevents, void *data)
     32 {
     33     struct input_event ev;
     34     int *key_code = (int *)data;
     35 
     36     *key_code = -1;
     37 
     38     if (ev_get_input(fd, epevents, &ev)) {
     39         return -1;
     40     }
     41 
     42     if (ev.type == EV_KEY && ev.value == 1) {
     43         *key_code = ev.code;
     44     }
     45 
     46     return 0;
     47 }
     48 
     49 static void clear()
     50 {
     51     gr_color(0, 0, 0, 0);
     52     gr_clear();
     53     gr_flip();
     54 }
     55 
     56 static void draw(const char *resname)
     57 {
     58     GRSurface* surface;
     59     int w, h, x, y;
     60 
     61     if (res_create_display_surface(resname, &surface) < 0) {
     62         LOGE("failed to create surface for %s\n", resname);
     63         return;
     64     }
     65 
     66     w = gr_get_width(surface);
     67     h = gr_get_height(surface);
     68     x = (gr_fb_width() - w) / 2;
     69     y = (gr_fb_height() - h) / 2;
     70 
     71     gr_blit(surface, 0, 0, w, h, x, y);
     72     gr_flip();
     73 
     74     res_free_surface(surface);
     75 }
     76 
     77 int usage()
     78 {
     79     LOGE("usage: slideshow [-t timeout] image.png [image2.png ...] last.png\n");
     80     return EXIT_FAILURE;
     81 }
     82 
     83 int main(int argc, char **argv)
     84 {
     85     int key_code = -1;
     86     int input = false;
     87     int opt;
     88     long int timeout = NEXT_TIMEOUT_MS;
     89     int64_t start;
     90 
     91     while ((opt = getopt(argc, argv, "t:")) != -1) {
     92         switch (opt) {
     93         case 't':
     94             timeout = strtol(optarg, NULL, 0);
     95 
     96             if (timeout < 0 || timeout >= LONG_MAX) {
     97                 timeout = NEXT_TIMEOUT_MS;
     98                 LOGE("invalid timeout %s, defaulting to %ld\n", optarg,
     99                     timeout);
    100             }
    101             break;
    102         default:
    103             return usage();
    104         }
    105     }
    106 
    107     if (optind >= argc) {
    108         return usage();
    109     }
    110 
    111     if (gr_init() == -1 || ev_init(input_cb, &key_code) == -1) {
    112         LOGE("failed to initialize minui\n");
    113         return EXIT_FAILURE;
    114     }
    115 
    116     /* display all images except the last one, switch to next image after
    117      * timeout or user input */
    118 
    119     while (optind < argc - 1) {
    120         draw(argv[optind++]);
    121 
    122         start = android::uptimeMillis();
    123         long int timeout_remaining = timeout;
    124         do {
    125             if (ev_wait(timeout_remaining) == 0) {
    126                 ev_dispatch();
    127 
    128                 if (key_code != -1) {
    129                     input = true;
    130                     break;
    131                 }
    132             }
    133             timeout_remaining -= android::uptimeMillis() - start;
    134         } while (timeout_remaining > 0);
    135     };
    136 
    137     /* if there was user input while showing the images, display the last
    138      * image and wait until the power button is pressed or LAST_TIMEOUT_MS
    139      * has elapsed */
    140 
    141     if (input) {
    142         start = android::uptimeMillis();
    143 
    144         draw(argv[optind]);
    145 
    146         do {
    147             if (ev_wait(timeout) == 0) {
    148                 ev_dispatch();
    149             }
    150 
    151             if (android::uptimeMillis() - start >= LAST_TIMEOUT_MS) {
    152                 break;
    153             }
    154         } while (key_code != KEY_POWER);
    155     }
    156 
    157     clear();
    158     gr_exit();
    159     ev_exit();
    160 
    161     return EXIT_SUCCESS;
    162 }
    163