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                 source.read_chars(buf, out count_read);
  55         stderr.printf("READ %zu chars\n", count_read);
  56
  57                 LinuxInput.Event* ie = (LinuxInput.Event*)buf;
  58         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);
  59
  60         /*
  61         ts1, ts2, type, code, value = struct.unpack("LLHHI", buf)
  62         #print ts1, ts2, type, code, value
  63         if type == 1 and code == 119:
  64             if value:
  65                 #print "BUTTON RELEASE"
  66                 pass
  67             else:
  68                 if self.last_button_press + 1 < ts1:
  69                     self.last_button_press = ts1
  70                     if self.button_press_handler is not None:
  71                         self.button_press_handler()
  72                     #print "BUTTON PRESS"
  73         elif type == 5 and code == 2:
  74             if value:
  75                 info("Headset plugged in")
  76                 self.mixer_for_headset(self)
  77             else:
  78                 info("Headset plugged out")
  79                 self.mixer_for_handset(self)
  80         */
  81         return event(ie);
  82     }
  83
  84         /// Start reading from the device
  85         public override void start()
  86         {
  87                 if (started) return;
  88
  89         if (fd != null)
  90             close_fd();
  91
  92         // Open the device and listed to it using the GObject main loop
  93         fd = new IOChannel.file(device, "r");
  94                 fd.set_encoding(null);
  95                 fd.set_buffered(false);
  96         fd_watch = fd.add_watch(IOCondition.IN, on_input_data);
  97
  98                 base.start();
  99         }
 100
 101         // Stop reading from the device
 102         public override void stop()
 103         {
 104                 if (!started) return;
 105
 106         if (fd != null)
 107         {
 108             Source.remove(fd_watch);
 109             close_fd();
 110         }
 111
 112                 base.stop();
 113         }
 114 }
 115
 116 public class PowerButton : DevInput
 117 {
 118         public signal void power_button(bool pressed);
 119
 120     public PowerButton()
 121     {
 122         name = "input.power_button";
 123         // FIXME: change to event0 for the power button
 124         // FIXME: change to event4 for the aux button and headset button
 125         //device = "/dev/input/event1";
 126         device = "/dev/input/event0";
 127
 128                 event += on_event;
 129     }
 130
 131         protected bool on_event(LinuxInput.Event* ev)
 132         {
 133                 if (ev->type == LinuxInput.Type.KEY &&
 134                         ev->code == LinuxInput.Key.POWER)
 135                 {
 136                         power_button(ev->val == 0 ? false : true);
 137                 }
 138                 return true;
 139         }
 140 }
 141
 142 /*
 143 # TODO:
 144 #  - hook into the headset plugged/unplugged event
 145 #  - if unplugged, turn on handset microphone
 146 #  - if plugged, redo headest mixer settings
 147 class Audio:
 148     "Handle mixer settings, audio recording and headset button presses"
 149     def __init__(self, button_press_handler = None):
 150         self.saved_scenario = os.path.expanduser("~/.audiomap.state")
 151
 152         # Setup the mixer
 153         # Set mixer to record from headset and handle headset button
 154         self.save_scenario(self.saved_scenario)
 155         self.load_scenario("/usr/share/openmoko/scenarios/voip-handset.state")
 156
 157         # This is a work-around because I have not found a way to query for the
 158         # current headset state, I can only know when it changes. So in my
 159         # system I configured oeventsd with a rule to touch this file when the
 160         # headset is plugged in, and remove the file when it's plugged out.
 161         if os.path.exists("/tmp/has_headset"):
 162             self.mixer_for_headset(True)
 163         else:
 164             self.mixer_for_handset(True)
 165
 166         #self.mixer_set("DAPM Handset Mic", "mute")
 167         #self.mixer_set("DAPM Headset Mic", "unmute")
 168         #self.mixer_set("Left Mixer Sidetone Playback Sw", "unmute")
 169         #self.mixer_set("ALC Mixer Mic1", "cap")
 170         #self.mixer_set("Amp Spk", "mute") # We don't need the phone playing what we say
 171
 172         # Watch the headset button
 173         self.button_press_handler = button_press_handler
 174         self.input_fd = open("/dev/input/event4", "rb")
 175         self.input_watch = gobject.io_add_watch(self.input_fd.fileno(), gobject.IO_IN, self.on_input_data)
 176
 177         self.last_button_press = 0
 178         self.recorder = None
 179         self.basename = None
 180
 181     def mixer_for_headset(self, force=False):
 182         if not force and self.has_headset: return
 183         info("Setting mixer for headset")
 184         # TODO: find out how to disable the handset microphone: this does not
 185         # seem to be sufficient
 186         self.mixer_set_many(
 187                 ("DAPM Handset Mic", "mute"),
 188                 ("DAPM Headset Mic", "unmute"),
 189                 ("Left Mixer Sidetone Playback Sw", "unmute"),
 190                 ("ALC Mixer Mic1", "cap"),
 191                 ("Amp Spk", "mute") # We don't need the phone playing what we say
 192         )
 193         self.has_headset = True
 194
 195     def mixer_for_handset(self, force=False):
 196         if not force and not self.has_headset: return
 197         info("Setting mixer for handset")
 198         self.mixer_set_many(
 199                 ("DAPM Handset Mic", "unmute"),
 200                 ("DAPM Headset Mic", "mute"),
 201                 ("Left Mixer Sidetone Playback Sw", "mute"),
 202                 ("ALC Mixer Mic1", "cap"),
 203                 ("Amp Spk", "mute") # We don't need the phone playing what we say
 204         )
 205         self.has_headset = False
 206
 207     def set_basename(self, basename):
 208         self.basename = basename
 209
 210     def start_recording(self):
 211         if self.basename is None:
 212             raise RuntimeError("Recording requested but basename not set")
 213         self.recorder = subprocess.Popen(
 214             ["arecord", "-D", "hw", "-f", "cd", "-r", "8000", "-t", "wav", self.basename + ".wav"])
 215
 216     def start_levels(self):
 217         self.recorder = subprocess.Popen(
 218             ["arecord", "-D", "hw", "-f", "cd", "-r", "8000", "-t", "wav", "-V", "stereo", "/dev/null"])
 219
 220     def close(self):
 221         if self.recorder is not None:
 222             os.kill(self.recorder.pid, signal.SIGINT)
 223             self.recorder.wait()
 224
 225         # Restore mixer settings
 226         self.load_scenario(self.saved_scenario)
 227
 228         gobject.source_remove(self.input_watch)
 229         self.input_fd.close()
 230
 231     def on_input_data(self, source, condition):
 232         buf = self.input_fd.read(16)
 233         ts1, ts2, type, code, value = struct.unpack("LLHHI", buf)
 234         #print ts1, ts2, type, code, value
 235         if type == 1 and code == 119:
 236             if value:
 237                 #print "BUTTON RELEASE"
 238                 pass
 239             else:
 240                 if self.last_button_press + 1 < ts1:
 241                     self.last_button_press = ts1
 242                     if self.button_press_handler is not None:
 243                         self.button_press_handler()
 244                     #print "BUTTON PRESS"
 245         elif type == 5 and code == 2:
 246             if value:
 247                 info("Headset plugged in")
 248                 self.mixer_for_headset(self)
 249             else:
 250                 info("Headset plugged out")
 251                 self.mixer_for_handset(self)
 252         return True
 253
 254     def save_scenario(self, name):
 255         res = subprocess.call(["alsactl", "store", "-f", name])
 256         if res != 0:
 257             raise RuntimeError("Saving audio scenario to '%s' failed" % name)
 258
 259     def load_scenario(self, name):
 260         res = subprocess.call(["alsactl", "restore", "-f", name])
 261         if res != 0:
 262             raise RuntimeError("Loading audio scenario '%s' failed" % name)
 263
 264     def mixer_set(self, name, *args):
 265         args = map(str, args)
 266         res = subprocess.call(["amixer", "-q", "set", name] + args)
 267         if res != 0:
 268             raise RuntimeError("Setting mixer '%s' to %s failed" % (name, " ".join(args)))
 269
 270     # Will do this when we find out the syntax for giving amixer commands on stdin
 271     def mixer_set_many(self, *args):
 272         """Perform many mixer set operations via amixer --stdin"""
 273         proc = subprocess.Popen(["amixer", "-q", "--stdin"], stdin=subprocess.PIPE)
 274         cmd_input = []
 275         for k, v in args:
 276             cmd_input.append("sset " + repr(k) + " " + repr(v))
 277         (out, err) = proc.communicate(input="\n".join(cmd_input))
 278         res = proc.wait()
 279         if res != 0:
 280             raise RuntimeError("Setting mixer failed")
 281 */
 282
 283 public PowerButton power_button = null;
 284
 285 public void init()
 286 {
 287         power_button = new PowerButton();
 288
 289         zavai.registry.register_service(power_button);
 290 }
 291
 292 }
 293 }