Workaround for freerunner battery
[gregoa/zavai.git] / src / app_power.vala
1 /*
2  * app_power - zavai power 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 using GLib;
22
23 namespace zavai {
24 namespace ui {
25 namespace power {
26
27 // Compute a-b in microseconds
28 static long timediff(Posix.timeval* a, Posix.timeval* b)
29 {
30         return (a->tv_sec - b->tv_sec) * 1000000 + (a->tv_usec - b->tv_usec);
31 }
32
33 public class Power : zavai.Resource, Object
34 {
35         public dynamic DBus.Object usage;
36         public bool screen_locked;
37         private int screen_lock_fd;
38         // Timestamp of the past power button pressed even (0 if the button has
39         // been released)
40         private Posix.timeval last_down;
41         private Posix.timeval last_short_press;
42
43         private bool hide_after_closing_power_menu;
44
45         public signal void screen_lock_changed(bool state);
46
47         public signal void power_short_press(Posix.timeval* t);
48         public signal void power_long_press();
49         private uint button_press_timeout;
50
51         public Power()
52         {
53                 screen_locked = false;
54                 screen_lock_fd = -1;
55                 hide_after_closing_power_menu = false;
56                 last_down.tv_sec = 0;
57                 last_down.tv_usec = 0;
58                 last_short_press.tv_sec = 0;
59                 last_short_press.tv_usec = 0;
60                 button_press_timeout = 0;
61
62                 usage = zavai.registry.sbus.get_object(
63                         "org.freesmartphone.ousaged",
64                         "/org/freesmartphone/Usage",
65                         "org.freesmartphone.Usage");
66
67                 zavai.input.power_button.power_button += on_power_button;
68                 zavai.input.power_button.request("zavai.ui.powerbutton.power");
69
70                 power_short_press += on_power_short_press;
71                 power_long_press += on_power_long_press;
72         }
73
74         public void shutdown()
75         {
76                 zavai.input.power_button.release("zavai.ui.powerbutton.power");
77         }
78
79         public void do_suspend()
80         {
81                 try {
82                         usage.Suspend();
83                 } catch (Error e) {
84                         zavai.log.error("Suspending phone: " + e.message);
85                 }
86         }
87         public void do_shutdown()
88         {
89                 try {
90                         //usage.Shutdown();
91                         zavai.app.run_script("shutdown -h now");
92                 } catch (Error e) {
93                         zavai.log.error("Shutting down phone: " + e.message);
94                 }
95         }
96         public void do_reboot()
97         {
98                 try {
99                         //usage.Reboot();
100                         zavai.app.run_script("shutdown -r now");
101                 } catch (Error e) {
102                         zavai.log.error("Rebooting phone: " + e.message);
103                 }
104         }
105
106         public void set_screen_lock(bool locked)
107         {
108                 if (locked && screen_locked)
109                         return;
110                 if (!locked && !screen_locked)
111                         return;
112
113                 if (locked)
114                 {
115                         screen_lock_fd = Posix.open("/dev/input/event1", Posix.O_RDWR | Posix.O_NONBLOCK);
116                         if (screen_lock_fd < 0)
117                         {
118                                 zavai.log.error("Cannot open /dev/input/event1");
119                                 return;
120                         }
121
122                         // FIXME: X won't see events, but it's still generating interrupts,
123                         // isn't it?
124                         int EVIOCGRAB = 0x40044590;
125                         if (Posix.ioctl(screen_lock_fd, EVIOCGRAB, locked ? 1 : 0) != 0)
126                         {
127                                 zavai.log.error("Cannot EVIOCGRAB /dev/input/event1");
128                                 Posix.close(screen_lock_fd);
129                                 return;
130                         }
131
132                         backlight.lock_screen();
133                 } else {
134                         Posix.close(screen_lock_fd);
135                         backlight.unlock_screen();
136                 }
137                 screen_locked = locked;
138                 if (!locked)
139                         backlight.wiggle();
140
141                 screen_lock_changed(locked);
142         }
143
144         private bool on_power_button_timeout()
145         {
146                 last_down.tv_sec = 0;
147                 last_down.tv_usec = 0;
148                 power_long_press();
149                 // Do not reschedule
150                 return false;
151         }
152
153         private void on_power_button(Posix.timeval* t, bool pressed)
154         {
155                 bool short_press = false;
156                 bool long_press = false;
157
158                 if (pressed)
159                 {
160                         if (last_down.tv_sec == 0)
161                         {
162                                 last_down = *t;
163                                 button_press_timeout = Timeout.add(1000, on_power_button_timeout);
164                         }
165                         else
166                         {
167                                 long diff = timediff(t, &last_down);
168                                 long_press = diff >= 1000000;
169                         }
170                 } else {
171                         if (last_down.tv_sec == 0)
172                         {
173                                 // Ignore: release has been simulated with the timeout
174                         } else {
175                                 if (button_press_timeout != 0)
176                                 {
177                                         // Cancel the timeout
178                                         Source.remove(button_press_timeout);
179                                         button_press_timeout = 0;
180                                 }
181                                 long diff = timediff(t, &last_down);
182                                 if (diff >= 1000000)
183                                         long_press = true;
184                                 else
185                                         short_press = true;
186
187                                 last_down.tv_sec = 0;
188                                 last_down.tv_usec = 0;
189                         }
190                 }
191
192                 if (long_press)
193                 {
194                         power_long_press();
195                         last_short_press.tv_sec = 0;
196                         last_short_press.tv_usec = 0;
197                 }
198                 if (short_press) power_short_press(t);
199         }
200
201         private void on_power_short_press(Posix.timeval* t)
202         {
203                 long diff = timediff(t, &last_short_press);
204                 bool combo = screen_locked && (diff <= 5000000);
205                 last_short_press = *t;
206
207                 if (screen_locked)
208                 {
209                         // Short press: turn on backlight for a bit
210                         backlight.wiggle();
211                         if (combo)
212                         {
213                                 app.back_to_main();
214                                 app.toggle_visibility();
215                         }
216                 }
217                 else
218                         // Short press: toggle power menu
219                         power_menu.toggle();
220         }
221
222         private void on_power_long_press()
223         {
224                 if (screen_locked)
225                         // Long press: unlock
226                         set_screen_lock(false);
227                 else
228                         // Long press: lock screen
229                         set_screen_lock(true);
230         }
231 }
232
233 public class BatteryIcon : Gtk.StatusIcon
234 {
235         //public dynamic DBus.Object battery;
236         public Dkp.Device battery;
237
238         public BatteryIcon(Dkp.Device dev)
239         {
240                 battery = dev;
241                 battery.changed += on_changed;
242
243                 stderr.printf("New battery icon for %s online %s perc %f isrec %s tte %lld ttf %lld\n", dev.native_path, dev.online ? "yes" : "no", dev.percentage, dev.is_rechargeable ? "yes" : "no", dev.time_to_empty, dev.time_to_full);
244
245                 /*
246                 battery = zavai.registry.sbus.get_object(
247                         "org.freesmartphone.odeviced",
248                         "/org/freesmartphone/Device/PowerSupply/battery",
249                         "org.freesmartphone.Device.PowerSupply");
250                 */
251
252                 // activate += on_activate;
253
254                 /*
255                 battery.PowerStatus += on_power_status;
256                 battery.Capacity += on_capacity;
257
258                 last_status = battery.GetPowerStatus();
259                 last_capacity = battery.GetCapacity();
260                 */
261                 
262                 update_icon();
263         }
264
265         private void on_changed(void* obj)
266         {
267                 update_icon();
268         }
269
270         /*
271         private void on_power_status(dynamic DBus.Object bat, string status)
272         {
273                 zavai.log.info("New battery status: " + status);
274                 last_status = status;
275                 update_icon();
276         }
277
278         private void on_capacity(dynamic DBus.Object bat, int val)
279         {
280 stderr.printf("NEW CAPACITY: %d\n", val);
281                 last_capacity = val;
282                 update_icon();
283         }
284         */
285
286         /*
287         private void on_activate()
288         {
289         }
290         */
291
292         protected void update_icon()
293         {
294                 string name = zavai.config.icondir + "/battery/";
295                 bool charging = false;
296                 Dkp.DeviceState state = (Dkp.DeviceState)battery.state;
297
298 stderr.printf("New battery status: %s\n", Dkp.Device.state_to_text(state));
299                 int capacity = (int)Math.round(battery.percentage/10);
300                 switch (state)
301                 {
302                         case Dkp.DeviceState.CHARGING:
303                                 name += "%02d0_charging_500.png".printf(capacity);
304                                 break;
305                         case Dkp.DeviceState.FULLY_CHARGED:
306                                 name += "100_charging_500.png";
307                                 break;
308                         case Dkp.DeviceState.UNKNOWN:
309                         case Dkp.DeviceState.DISCHARGING:
310                         case Dkp.DeviceState.EMPTY:
311                         case Dkp.DeviceState.PENDING_CHARGE:
312                         case Dkp.DeviceState.PENDING_DISCHARGE:
313                         case Dkp.DeviceState.LAST:
314                                 name += "%02d0.png".printf(capacity);
315                                 break;
316                 }
317
318 stderr.printf("Loading icon from %s\n", name);
319
320                 set_from_file(name);
321         }
322 }
323
324 public class ScreenLockButton : Gtk.Button
325 {
326         public ScreenLockButton()
327         {
328                 label = "Lock screen";
329                 clicked += on_clicked;
330                 set_size_request(0, zavai.config.min_button_height);
331         }
332
333         public void on_clicked()
334         {
335                 zavai.log.info("Locking screen");
336                 power.set_screen_lock(true);
337                 power_menu.hide_menu();
338         }
339 }
340
341 public class SuspendButton : Gtk.Button
342 {
343         public SuspendButton()
344         {
345                 label = "Suspend";
346                 clicked += on_clicked;
347                 set_size_request(0, zavai.config.min_button_height);
348         }
349
350         public void on_clicked()
351         {
352                 zavai.log.info("Suspending the phone via FSO");
353                 power.do_suspend();
354                 power_menu.hide_menu();
355         }
356 }
357
358 public class ShutdownButton : Gtk.Button
359 {
360         public ShutdownButton()
361         {
362                 label = "Shut down";
363                 clicked += on_clicked;
364                 set_size_request(0, zavai.config.min_button_height);
365         }
366
367         public void on_clicked()
368         {
369                 zavai.log.info("Shutting down the phone via FSO");
370                 power.do_shutdown();
371                 power_menu.hide_menu();
372         }
373 }
374
375 public class RebootButton : Gtk.Button
376 {
377         public RebootButton()
378         {
379                 label = "Reboot";
380                 clicked += on_clicked;
381                 set_size_request(0, zavai.config.min_button_height);
382         }
383
384         public void on_clicked()
385         {
386                 zavai.log.info("Rebooting the phone via FSO");
387                 power.do_reboot();
388                 power_menu.hide_menu();
389         }
390 }
391
392 // For a list of dbus services, look in /etc/dbus-1/system.d/
393 public class Backlight: zavai.Service
394 {
395         public dynamic DBus.Object usage;
396
397         public Backlight()
398         {
399                 name = "backlight";
400
401                 usage = zavai.registry.sbus.get_object(
402                         "org.freesmartphone.ousaged",
403                         "/org/freesmartphone/Usage",
404                         "org.freesmartphone.Usage");
405         }
406
407         // Turn the backlight and then let it fade off
408         public void wiggle()
409         {
410                 // There must be a better method
411                 try {
412                         //display.SetBacklightPower(true);
413                         //usage.SetResourcePolicy("Display", "auto");
414                         //usage.RequestResource("Display");
415                         //usage.ReleaseResource("Display");
416                         zavai.app.run_script(zavai.config.homedir + "/display wiggle");
417                 } catch (Error e) {
418                         zavai.log.error("Requesting/releasing resource Display: " + e.message);
419                 }
420         }
421
422         public void lock_screen()
423         {
424                 if (!started)
425                 {
426                         try {
427                                 //display.SetBacklightPower(false);
428                                 zavai.app.run_script(zavai.config.homedir + "/display lock_off");
429                                 /*
430                                 string policy = usage.GetResourcePolicy("Display");
431                                 if (policy == "auto")
432                                 {
433                                         usage.SetResourcePolicy("Display", "disabled");
434                                 }
435                                 */
436                         } catch (GLib.Error e) {
437                                 zavai.log.error(e.message);
438                         }
439                 }
440         }
441
442         public void unlock_screen()
443         {
444                 try {
445                         //display.SetBacklightPower(true);
446                         zavai.app.run_script(zavai.config.homedir + "/display defaults");
447                         //usage.SetResourcePolicy("Display", "auto");
448                 } catch (GLib.Error e) {
449                         zavai.log.error(e.message);
450                 }
451         }
452
453
454         /// Request GPS resource
455         public override void start()
456         {
457                 if (started) return;
458                 try {
459                         //usage.RequestResource("Display");
460                         zavai.app.run_script(zavai.config.homedir + "/display lock_on");
461                         zavai.log.info("Acquired display");
462                         base.start();
463                 } catch (GLib.Error e) {
464                         zavai.log.error(e.message);
465                 }
466                 base.start();
467         }
468
469         // Release usage of GPS
470         public override void stop()
471         {
472                 if (!started) return;
473                 try {
474                         //usage.ReleaseResource("Display");
475                         zavai.app.run_script(zavai.config.homedir + "/display defaults");
476                         zavai.log.info("Released display");
477                         base.stop();
478                 } catch (GLib.Error e) {
479                         zavai.log.error(e.message);
480                 }
481                 base.stop();
482         }
483 }
484
485 public class PowerMenu : zavai.Resource, Gtk.Window
486 {
487         protected Gtk.VBox vbox;
488         protected ScreenLockButton act_screen_lock;
489         protected SuspendButton act_suspend;
490         protected ShutdownButton act_shutdown;
491         protected RebootButton act_reboot;
492         protected ServiceRequestLink act_backlight_on;
493         protected bool shown;
494
495         public PowerMenu()
496         {
497                 type = Gtk.WindowType.TOPLEVEL;
498                 title = "Power Menu";
499                 shown = false;
500                 destroy_with_parent = true;
501                 set_transient_for(zavai.app);
502                 set_modal(true);
503                 set_position(Gtk.WindowPosition.CENTER_ON_PARENT);
504                 set_size_request(300, 500);
505
506                 vbox = new Gtk.VBox(false, 0);
507                 add(vbox);
508
509                 //destroy += Gtk.main_quit;
510                 //set_events(get_events() | Gdk.EventMask.VISIBILITY_NOTIFY_MASK);
511                 //visibility_notify_event += on_visibility;
512                 set_skip_pager_hint(true);
513                 set_skip_taskbar_hint(true);
514                 set_type_hint(Gdk.WindowTypeHint.POPUP_MENU);
515
516                 act_screen_lock = new ScreenLockButton();
517                 vbox.pack_start(act_screen_lock, false, false, 0);
518
519                 act_suspend = new SuspendButton();
520                 vbox.pack_start(act_suspend, false, false, 0);
521
522                 act_shutdown = new ShutdownButton();
523                 vbox.pack_start(act_shutdown, false, false, 0);
524
525                 act_reboot = new RebootButton();
526                 vbox.pack_start(act_reboot, false, false, 0);
527
528                 act_backlight_on = new ServiceRequestLink("backlight", "Keep backlight on", "Let backlight fade");
529                 act_backlight_on.toggled += (src) => { this.hide_menu(); };
530                 vbox.pack_start(act_backlight_on, false, false, 0);
531
532                 //vbox.show_all();
533         }
534
535         public void toggle()
536         {
537                 if (!shown)
538                 {
539                         show_all();
540                         show();
541                         visible = true;
542                         present();
543                         shown = true;
544                 } else {
545                         // TODO: do more in case it is visible but has no visibility (is covered by others)
546                         visible = !visible;
547                         if (visible)
548                                 present();
549                 }                               
550         }
551
552         public void hide_menu()
553         {
554                 visible = false;
555         }
556
557         public void shutdown() {}
558 }
559
560 /*
561 public class TogglePowerMenu : Gtk.Button
562 {
563         public TogglePowerMenu()
564         {
565                 label = "Toggle power menu";
566                 clicked += on_clicked;
567                 set_size_request(0, zavai.config.min_button_height);
568         }
569
570         public void on_clicked()
571         {
572                 zavai.log.info("Toggling power menu");
573                 power_menu.toggle();
574         }
575 }
576 */
577
578 Power power;
579 PowerMenu power_menu;
580 Gee.ArrayList<BatteryIcon> battery_icons;
581 Backlight backlight;
582 //TogglePowerMenu tpm;
583
584 public void init()
585 {
586         power = new Power();
587         backlight = new Backlight();
588         zavai.registry.register_service(backlight);
589         
590         battery_icons = new Gee.ArrayList<BatteryIcon>();
591         // Enumerate batteries
592         var c = new Dkp.Client();
593         unowned GLib.PtrArray devs = c.enumerate_devices();
594         for (int i = 0; i < devs.len; ++i)
595         {
596                 Dkp.Device dev = (Dkp.Device)devs.pdata[i];
597                 stderr.printf("Found new device %s\n", dev.native_path);
598                 dev.print();
599                 stderr.printf("Rechargeable: %s\n", def.is_rechargeable ? "yes" : "no");
600                 // On the FreeRunner, for some reason the battery does not
601                 // appear as rechargeable, so I also match it literally
602                 if (!dev.is_rechargeable || dev.native_path != "/sys/class/power_supply/battery") continue;
603                 var bi = new BatteryIcon(dev);
604                 bi.set_visible(true);
605                 battery_icons.add(bi);
606         }
607
608         power_menu = new PowerMenu();
609         zavai.registry.register_resource("powermenu", power_menu);
610         
611     //zavai.registry.getmenu("menu.main").add_applet("menu.power");
612         //tpm = new TogglePowerMenu();
613     //zavai.registry.getmenu("menu.main").add_widget(tpm);
614
615     /*
616         raise_icon = new RaiseIcon();
617         raise_icon.set_visible(true);
618
619         close_or_back = new CloseOrBack();
620         close_or_back.set_visible(true);
621
622         window_list = new WindowList("Current apps");
623         zavai.registry.register_applet("wm.list", window_list);
624         zavai.registry.getmenu("menu.main").add_applet("wm.list");
625
626         try {
627                 launcher = new Launcher("Run program");
628         } catch (Error e) {
629                 zavai.log.error("Not running launcher: " + e.message);
630                 launcher = null;
631         }
632
633         if (launcher != null)
634         {
635                 zavai.registry.register_applet("wm.launcher", launcher);
636                 zavai.registry.getmenu("menu.main").add_applet("wm.launcher");
637         }
638     */
639 }
640
641 }
642 }
643 }