N900/ButtonListener.cpp

#include "ButtonListener.h"
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/fcntl.h>
#include <poll.h>
#include <unistd.h>

#include <sstream>

#include "../Event.h" 
#include "../Time.h" 

namespace FCam { 
    namespace N900 {

    void *button_listener_thread_(void *arg) {
        ButtonListener *b = (ButtonListener *)arg;
        b->run();    
        pthread_exit(NULL);
        return NULL;
    }
    
    ButtonListener *ButtonListener::instance() {
        if (!_instance) {
        _instance = new ButtonListener;
        }
        return _instance;
    }
    
    ButtonListener::ButtonListener() : stop(false) {
        pthread_attr_t attr;
        struct sched_param param;
        
        // make the thread
        
        param.sched_priority = sched_get_priority_max(SCHED_OTHER);     
        
        pthread_attr_init(&attr);
        
        if ((errno =
         -(pthread_attr_setschedparam(&attr, &param) ||
           pthread_attr_setschedpolicy(&attr, SCHED_OTHER) ||
           pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) ||
           pthread_create(&thread, &attr, button_listener_thread_, this)))) {
        perror("Error creating button listener thread");
        }

    }

    ButtonListener::~ButtonListener() {
        stop = true;
        pthread_join(thread, NULL);
    }

    void ButtonListener::run() {
        #define BUTTONS 4

        const char *fnames[BUTTONS] = {"/sys/devices/platform/gpio-switch/cam_shutter/state",
                       "/sys/devices/platform/gpio-switch/cam_focus/state",
                       "/sys/devices/platform/gpio-switch/cam_launch/state",
                       "/sys/devices/platform/gpio-switch/slide/state"};
                        
        char buf[81];

        bool state[BUTTONS];

        int event[BUTTONS*2] = {Event::N900LensOpened,
                    Event::N900LensClosed,
                    Event::FocusPressed,
                    Event::FocusReleased,
                    Event::ShutterPressed,
                    Event::ShutterReleased,
                    Event::N900SlideOpened,
                    Event::N900SlideClosed};
        // open all the devices
        int rval;
        struct pollfd fds[BUTTONS];
        for (int i = 0; i < BUTTONS; i++) {
        fds[i].fd = open(fnames[i], O_RDONLY);
        fds[i].events = POLLPRI;
        fds[i].revents = 0;
        }

        // read the initial state
        for (int i = 0; i < BUTTONS; i++) {
        rval = read(fds[i].fd, &buf, 80);
        buf[rval] = 0;
        switch (buf[0]) {
        case 'c': // closed
        case 'i': // inactive
            state[i] = false;
            break;
        case 'o': // open
        case 'a': // active
            state[i] = true;
            break;
        default:
            printf("ButtonListener: Unknown state: %s\n", buf);
        }
        }       

        while (!stop) {        
        // wait for a change
        rval = poll(fds, BUTTONS, 1000);
        if (rval == -1) {
            perror("poll");
            break;
        }
        if (rval == 0) continue; // timeout

        for (int i = 0; i < BUTTONS; i++) {
            if (fds[i].revents & POLLPRI) {
            close(fds[i].fd);
            fds[i].fd = open(fnames[i], O_RDONLY, 0);
            rval = read(fds[i].fd, &buf, 80);
            buf[rval] = 0;
            switch (buf[0]) {
            case 'c': // closed
            case 'i': // inactive
                if (state[i] != false) {
                state[i] = false;
                Event e;
                e.type = event[i*2+1];
                e.iData = 0;
                e.time = Time::now();
                postEvent(e);
                }
                break;
            case 'o': // open
            case 'a': // active
                if (state[i] != true) {
                state[i] = true;
                Event e;
                e.type = event[i*2];
                e.iData = 0;
                e.time = Time::now();
                postEvent(e);
                }
                break;
            default:
                printf("ButtonListener: Unknown state: %s\n", buf);
            }
            }
        }       
        }

        for (int i = 0; i < BUTTONS; i++) {
        close(fds[i].fd);
        }
    }

        int event[BUTTONS*2] = {Event::N900LensOpened,
                    Event::N900LensClosed,
                    Event::FocusPressed,
                    Event::FocusReleased,
                    Event::ShutterPressed,
                    Event::ShutterReleased,
                    Event::N900SlideOpened,
                    Event::N900SlideClosed};

    std::string ButtonListener::getEventString(const Event &e) const {
        std::string str;
        switch (e.type) {
        case Event::ShutterPressed:
        str = "Shutter button pressed";
        return str;
        case Event::ShutterReleased:
        str = "Shutter button released";
        return str;
        case Event::FocusPressed:
        str = "Focus button pressed";
        return str;
        case Event::FocusReleased:
        str = "Focus button released";
        return str;
        case Event::N900LensOpened:
        str = "Lens cover opened";
        return str;
        case Event::N900LensClosed:
        str = "Lens cover closed";
        return str;
        case Event::N900SlideOpened:
        str = "Keyboard slide opened";
        return str;
        case Event::N900SlideClosed:
        str = "Keyboard slide closed";
        return str;
        };

        str = "Unknown N900 Button Event";
        return str;
    }

    ButtonListener *ButtonListener::_instance = NULL;
    }
}

---