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                 zavai.log.info("Opening device " + device);
  94         fd = new IOChannel.file(device, "r");
  95                 fd.set_encoding(null);
  96                 fd.set_buffered(false);
  97         fd_watch = fd.add_watch(IOCondition.IN, on_input_data);
  98
  99                 base.start();
 100         }
 101
 102         // Stop reading from the device
 103         public override void stop()
 104         {
 105                 if (!started) return;
 106
 107         if (fd != null)
 108         {
 109             Source.remove(fd_watch);
 110             close_fd();
 111         }
 112
 113                 base.stop();
 114         }
 115 }
 116
 117 public class PowerButton : DevInput
 118 {
 119         public signal void power_button(Posix.timeval* time, bool pressed);
 120
 121     public PowerButton()
 122     {
 123         name = "input.power_button";
 124         // FIXME: change to event0 for the power button
 125         // FIXME: change to event4 for the aux button and headset button
 126         //device = "/dev/input/event1";
 127         device = "/dev/input/event0";
 128
 129                 event += on_event;
 130                 power_button += on_power_button;
 131     }
 132
 133         protected bool on_event(LinuxInput.Event* ev)
 134         {
 135                 if (ev->type == LinuxInput.Type.KEY &&
 136                         ev->code == LinuxInput.Key.POWER)
 137                 {
 138                         power_button(&(ev->time), ev->val == 0 ? false : true);
 139                 }
 140                 return true;
 141         }
 142
 143         protected void on_power_button(Posix.timeval* time, bool pressed)
 144         {
 145                 if (!pressed)
 146                 {
 147                         zavai.app.push_applet("menu.power");
 148                 }
 149         }
 150 }
 151
 152 /*
 153 # TODO:
 154 #  - hook into the headset plugged/unplugged event
 155 #  - if unplugged, turn on handset microphone
 156 #  - if plugged, redo headest mixer settings
 157 class Audio:
 158     "Handle mixer settings, audio recording and headset button presses"
 159     def __init__(self, button_press_handler = None):
 160         self.saved_scenario = os.path.expanduser("~/.audiomap.state")
 161
 162         # Setup the mixer
 163         # Set mixer to record from headset and handle headset button
 164         self.save_scenario(self.saved_scenario)
 165         self.load_scenario("/usr/share/openmoko/scenarios/voip-handset.state")
 166
 167         # This is a work-around because I have not found a way to query for the
 168         # current headset state, I can only know when it changes. So in my
 169         # system I configured oeventsd with a rule to touch this file when the
 170         # headset is plugged in, and remove the file when it's plugged out.
 171         if os.path.exists("/tmp/has_headset"):
 172             self.mixer_for_headset(True)
 173         else:
 174             self.mixer_for_handset(True)
 175
 176         #self.mixer_set("DAPM Handset Mic", "mute")
 177         #self.mixer_set("DAPM Headset Mic", "unmute")
 178         #self.mixer_set("Left Mixer Sidetone Playback Sw", "unmute")
 179         #self.mixer_set("ALC Mixer Mic1", "cap")
 180         #self.mixer_set("Amp Spk", "mute") # We don't need the phone playing what we say
 181
 182         # Watch the headset button
 183         self.button_press_handler = button_press_handler
 184         self.input_fd = open("/dev/input/event4", "rb")
 185         self.input_watch = gobject.io_add_watch(self.input_fd.fileno(), gobject.IO_IN, self.on_input_data)
 186
 187         self.last_button_press = 0
 188         self.recorder = None
 189         self.basename = None
 190
 191     def mixer_for_headset(self, force=False):
 192         if not force and self.has_headset: return
 193         info("Setting mixer for headset")
 194         # TODO: find out how to disable the handset microphone: this does not
 195         # seem to be sufficient
 196         self.mixer_set_many(
 197                 ("DAPM Handset Mic", "mute"),
 198                 ("DAPM Headset Mic", "unmute"),
 199                 ("Left Mixer Sidetone Playback Sw", "unmute"),
 200                 ("ALC Mixer Mic1", "cap"),
 201                 ("Amp Spk", "mute") # We don't need the phone playing what we say
 202         )
 203         self.has_headset = True
 204
 205     def mixer_for_handset(self, force=False):
 206         if not force and not self.has_headset: return
 207         info("Setting mixer for handset")
 208         self.mixer_set_many(
 209                 ("DAPM Handset Mic", "unmute"),
 210                 ("DAPM Headset Mic", "mute"),
 211                 ("Left Mixer Sidetone Playback Sw", "mute"),
 212                 ("ALC Mixer Mic1", "cap"),
 213                 ("Amp Spk", "mute") # We don't need the phone playing what we say
 214         )
 215         self.has_headset = False
 216
 217     def set_basename(self, basename):
 218         self.basename = basename
 219
 220     def start_recording(self):
 221         if self.basename is None:
 222             raise RuntimeError("Recording requested but basename not set")
 223         self.recorder = subprocess.Popen(
 224             ["arecord", "-D", "hw", "-f", "cd", "-r", "8000", "-t", "wav", self.basename + ".wav"])
 225
 226     def start_levels(self):
 227         self.recorder = subprocess.Popen(
 228             ["arecord", "-D", "hw", "-f", "cd", "-r", "8000", "-t", "wav", "-V", "stereo", "/dev/null"])
 229
 230     def close(self):
 231         if self.recorder is not None:
 232             os.kill(self.recorder.pid, signal.SIGINT)
 233             self.recorder.wait()
 234
 235         # Restore mixer settings
 236         self.load_scenario(self.saved_scenario)
 237
 238         gobject.source_remove(self.input_watch)
 239         self.input_fd.close()
 240
 241     def on_input_data(self, source, condition):
 242         buf = self.input_fd.read(16)
 243         ts1, ts2, type, code, value = struct.unpack("LLHHI", buf)
 244         #print ts1, ts2, type, code, value
 245         if type == 1 and code == 119:
 246             if value:
 247                 #print "BUTTON RELEASE"
 248                 pass
 249             else:
 250                 if self.last_button_press + 1 < ts1:
 251                     self.last_button_press = ts1
 252                     if self.button_press_handler is not None:
 253                         self.button_press_handler()
 254                     #print "BUTTON PRESS"
 255         elif type == 5 and code == 2:
 256             if value:
 257                 info("Headset plugged in")
 258                 self.mixer_for_headset(self)
 259             else:
 260                 info("Headset plugged out")
 261                 self.mixer_for_handset(self)
 262         return True
 263
 264     def save_scenario(self, name):
 265         res = subprocess.call(["alsactl", "store", "-f", name])
 266         if res != 0:
 267             raise RuntimeError("Saving audio scenario to '%s' failed" % name)
 268
 269     def load_scenario(self, name):
 270         res = subprocess.call(["alsactl", "restore", "-f", name])
 271         if res != 0:
 272             raise RuntimeError("Loading audio scenario '%s' failed" % name)
 273
 274     def mixer_set(self, name, *args):
 275         args = map(str, args)
 276         res = subprocess.call(["amixer", "-q", "set", name] + args)
 277         if res != 0:
 278             raise RuntimeError("Setting mixer '%s' to %s failed" % (name, " ".join(args)))
 279
 280     # Will do this when we find out the syntax for giving amixer commands on stdin
 281     def mixer_set_many(self, *args):
 282         """Perform many mixer set operations via amixer --stdin"""
 283         proc = subprocess.Popen(["amixer", "-q", "--stdin"], stdin=subprocess.PIPE)
 284         cmd_input = []
 285         for k, v in args:
 286             cmd_input.append("sset " + repr(k) + " " + repr(v))
 287         (out, err) = proc.communicate(input="\n".join(cmd_input))
 288         res = proc.wait()
 289         if res != 0:
 290             raise RuntimeError("Setting mixer failed")
 291 */
 292 public class CommandButton : Gtk.Button
 293 {
 294         private string command;
 295
 296         public CommandButton(string name, string command)
 297         {
 298                 label = name;
 299                 this.command = command;
 300                 clicked += on_clicked;
 301                 set_size_request(0, zavai.config.min_button_height);
 302         }
 303
 304         public void on_clicked()
 305         {
 306                 zavai.log.info("Run program: " + command);
 307                 string[] args = command.split(" ");
 308                 Pid pid;
 309                 Process.spawn_async(
 310                         Environment.get_home_dir(),
 311                         args,
 312                         null,
 313                         SpawnFlags.SEARCH_PATH,
 314                         null,
 315                         out pid);
 316         }
 317 }
 318
 319
 320 public PowerButton power_button = null;
 321
 322 public void init()
 323 {
 324         power_button = new PowerButton();
 325
 326         zavai.registry.register_service(power_button);
 327 }
 328
 329 public void ui_init()
 330 {
 331     // Menus
 332     var menu_power = new zavai.Menu("Power menu");
 333         menu_power.add_widget(new CommandButton("Suspend", "apm -s"));
 334         menu_power.add_widget(new CommandButton("Shutdown", "shutdown -h now"));
 335         menu_power.add_widget(new CommandButton("Reboot", "shutdown -r now"));
 336     zavai.registry.register_menu("menu.power", menu_power);
 337
 338     zavai.registry.getmenu("menu.main").add_applet("menu.power");
 339 }
 340
 341 }
 342 }