src/input.vala

   1 /*
   2  * devinput - zavai /dev/input device handling
   3  *
   4  * Copyright (C) 2009  Enrico Zini <enrico@enricozini.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 namespace zavai {
  22 namespace input {
  23
  24 public abstract class DevInput : zavai.Service
  25 {
  26     public string device { get; construct; }
  27
  28     public signal bool event(LinuxInput.Event* ev);
  29
  30     protected IOChannel fd = null;
  31     protected uint fd_watch = 0;
  32
  33     protected void close_fd()
  34     {
  35         if (fd != null)
  36         {
  37             try {
  38                 fd.shutdown(false);
  39             } catch (IOChannelError e) {
  40                 zavai.log.error("When closing " + device + ": " + e.message);
  41             }
  42
  43             fd = null;
  44         }
  45     }
  46
  47     protected bool on_input_data(IOChannel source, IOCondition condition)
  48     {
  49         if (condition != IOCondition.IN) return true;
  50
  51         //stderr.printf("GOT INPUT ON %s %d\n", device, source.unix_get_fd());
  52         char[] buf = new char[sizeof(LinuxInput.Event)];
  53         size_t count_read;
  54         try {
  55             source.read_chars(buf, out count_read);
  56         } catch (Error e) {
  57             zavai.log.error("Reading from " + device + ": " + e.message);
  58             return true;
  59         }
  60         //stderr.printf("READ %zu chars\n", count_read);
  61
  62         LinuxInput.Event* ie = (LinuxInput.Event*)buf;
  63         //stderr.printf("INPUT EVENT time %lu.%lu type %hu code %hu val %d\n", (ulong)ie->time.tv_sec, ie->time.tv_usec, ie->type, ie->code, ie->val);
  64
  65         /*
  66         ts1, ts2, type, code, value = struct.unpack("LLHHI", buf)
  67         #print ts1, ts2, type, code, value
  68         if type == 1 and code == 119:
  69             if value:
  70                 #print "BUTTON RELEASE"
  71                 pass
  72             else:
  73                 if self.last_button_press + 1 < ts1:
  74                     self.last_button_press = ts1
  75                     if self.button_press_handler is not None:
  76                         self.button_press_handler()
  77                     #print "BUTTON PRESS"
  78         elif type == 5 and code == 2:
  79             if value:
  80                 info("Headset plugged in")
  81                 self.mixer_for_headset(self)
  82             else:
  83                 info("Headset plugged out")
  84                 self.mixer_for_handset(self)
  85         */
  86         return event(ie);
  87     }
  88
  89     /// Start reading from the device
  90     public override void start()
  91     {
  92         if (started) return;
  93
  94         if (fd != null)
  95             close_fd();
  96
  97         // Open the device and listed to it using the GObject main loop
  98         zavai.log.info("Opening device " + device);
  99         fd = new IOChannel.file(device, "r");
 100         try {
 101             fd.set_encoding(null);
 102         } catch (Error e) {
 103             zavai.log.error("Setting encoding to null on " + device + ": " + e.message);
 104         }
 105         fd.set_buffered(false);
 106         fd_watch = fd.add_watch(IOCondition.IN, on_input_data);
 107
 108         base.start();
 109     }
 110
 111     // Stop reading from the device
 112     public override void stop()
 113     {
 114         if (!started) return;
 115
 116         if (fd != null)
 117         {
 118             Source.remove(fd_watch);
 119             close_fd();
 120         }
 121
 122         base.stop();
 123     }
 124 }
 125
 126 public class PowerButton : DevInput
 127 {
 128     public signal void power_button(Posix.timeval* time, bool pressed);
 129
 130     public PowerButton()
 131     {
 132         // FIXME: change to event0 for the power button
 133         // FIXME: change to event4 for the aux button and headset button
 134         //device = "/dev/input/event1";
 135         Object(
 136         name: "input.power_button",
 137         device: "/dev/input/event0"
 138     );
 139
 140         event += on_event;
 141     }
 142
 143     protected bool on_event(LinuxInput.Event* ev)
 144     {
 145         if (ev->type == LinuxInput.Type.KEY &&
 146             ev->code == LinuxInput.Key.POWER)
 147         {
 148             power_button(&(ev->time), ev->val == 0 ? false : true);
 149         }
 150         return true;
 151     }
 152 }
 153
 154 /*
 155 # TODO:
 156 #  - hook into the headset plugged/unplugged event
 157 #  - if unplugged, turn on handset microphone
 158 #  - if plugged, redo headest mixer settings
 159 class Audio:
 160     "Handle mixer settings, audio recording and headset button presses"
 161     def __init__(self, button_press_handler = None):
 162         self.saved_scenario = os.path.expanduser("~/.audiomap.state")
 163
 164         # Setup the mixer
 165         # Set mixer to record from headset and handle headset button
 166         self.save_scenario(self.saved_scenario)
 167         self.load_scenario("/usr/share/openmoko/scenarios/voip-handset.state")
 168
 169         # This is a work-around because I have not found a way to query for the
 170         # current headset state, I can only know when it changes. So in my
 171         # system I configured oeventsd with a rule to touch this file when the
 172         # headset is plugged in, and remove the file when it's plugged out.
 173         if os.path.exists("/tmp/has_headset"):
 174             self.mixer_for_headset(True)
 175         else:
 176             self.mixer_for_handset(True)
 177
 178         #self.mixer_set("DAPM Handset Mic", "mute")
 179         #self.mixer_set("DAPM Headset Mic", "unmute")
 180         #self.mixer_set("Left Mixer Sidetone Playback Sw", "unmute")
 181         #self.mixer_set("ALC Mixer Mic1", "cap")
 182         #self.mixer_set("Amp Spk", "mute") # We don't need the phone playing what we say
 183
 184         # Watch the headset button
 185         self.button_press_handler = button_press_handler
 186         self.input_fd = open("/dev/input/event4", "rb")
 187         self.input_watch = gobject.io_add_watch(self.input_fd.fileno(), gobject.IO_IN, self.on_input_data)
 188
 189         self.last_button_press = 0
 190         self.recorder = None
 191         self.basename = None
 192
 193     def mixer_for_headset(self, force=False):
 194         if not force and self.has_headset: return
 195         info("Setting mixer for headset")
 196         # TODO: find out how to disable the handset microphone: this does not
 197         # seem to be sufficient
 198         self.mixer_set_many(
 199                 ("DAPM Handset Mic", "mute"),
 200                 ("DAPM Headset Mic", "unmute"),
 201                 ("Left Mixer Sidetone Playback Sw", "unmute"),
 202                 ("ALC Mixer Mic1", "cap"),
 203                 ("Amp Spk", "mute") # We don't need the phone playing what we say
 204         )
 205         self.has_headset = True
 206
 207     def mixer_for_handset(self, force=False):
 208         if not force and not self.has_headset: return
 209         info("Setting mixer for handset")
 210         self.mixer_set_many(
 211                 ("DAPM Handset Mic", "unmute"),
 212                 ("DAPM Headset Mic", "mute"),
 213                 ("Left Mixer Sidetone Playback Sw", "mute"),
 214                 ("ALC Mixer Mic1", "cap"),
 215                 ("Amp Spk", "mute") # We don't need the phone playing what we say
 216         )
 217         self.has_headset = False
 218
 219     def set_basename(self, basename):
 220         self.basename = basename
 221
 222     def start_recording(self):
 223         if self.basename is None:
 224             raise RuntimeError("Recording requested but basename not set")
 225         self.recorder = subprocess.Popen(
 226             ["arecord", "-D", "hw", "-f", "cd", "-r", "8000", "-t", "wav", self.basename + ".wav"])
 227
 228     def start_levels(self):
 229         self.recorder = subprocess.Popen(
 230             ["arecord", "-D", "hw", "-f", "cd", "-r", "8000", "-t", "wav", "-V", "stereo", "/dev/null"])
 231
 232     def close(self):
 233         if self.recorder is not None:
 234             os.kill(self.recorder.pid, signal.SIGINT)
 235             self.recorder.wait()
 236
 237         # Restore mixer settings
 238         self.load_scenario(self.saved_scenario)
 239
 240         gobject.source_remove(self.input_watch)
 241         self.input_fd.close()
 242
 243     def on_input_data(self, source, condition):
 244         buf = self.input_fd.read(16)
 245         ts1, ts2, type, code, value = struct.unpack("LLHHI", buf)
 246         #print ts1, ts2, type, code, value
 247         if type == 1 and code == 119:
 248             if value:
 249                 #print "BUTTON RELEASE"
 250                 pass
 251             else:
 252                 if self.last_button_press + 1 < ts1:
 253                     self.last_button_press = ts1
 254                     if self.button_press_handler is not None:
 255                         self.button_press_handler()
 256                     #print "BUTTON PRESS"
 257         elif type == 5 and code == 2:
 258             if value:
 259                 info("Headset plugged in")
 260                 self.mixer_for_headset(self)
 261             else:
 262                 info("Headset plugged out")
 263                 self.mixer_for_handset(self)
 264         return True
 265
 266     def save_scenario(self, name):
 267         res = subprocess.call(["alsactl", "store", "-f", name])
 268         if res != 0:
 269             raise RuntimeError("Saving audio scenario to '%s' failed" % name)
 270
 271     def load_scenario(self, name):
 272         res = subprocess.call(["alsactl", "restore", "-f", name])
 273         if res != 0:
 274             raise RuntimeError("Loading audio scenario '%s' failed" % name)
 275
 276     def mixer_set(self, name, *args):
 277         args = map(str, args)
 278         res = subprocess.call(["amixer", "-q", "set", name] + args)
 279         if res != 0:
 280             raise RuntimeError("Setting mixer '%s' to %s failed" % (name, " ".join(args)))
 281
 282     # Will do this when we find out the syntax for giving amixer commands on stdin
 283     def mixer_set_many(self, *args):
 284         """Perform many mixer set operations via amixer --stdin"""
 285         proc = subprocess.Popen(["amixer", "-q", "--stdin"], stdin=subprocess.PIPE)
 286         cmd_input = []
 287         for k, v in args:
 288             cmd_input.append("sset " + repr(k) + " " + repr(v))
 289         (out, err) = proc.communicate(input="\n".join(cmd_input))
 290         res = proc.wait()
 291         if res != 0:
 292             raise RuntimeError("Setting mixer failed")
 293 */
 294
 295
 296 public PowerButton power_button = null;
 297
 298 public void init()
 299 {
 300     power_button = new PowerButton();
 301 }
 302
 303 }
 304 }