Merge branch 'master' into gregoa
[gregoa/zavai.git] / src / gsm.vala
1 /*
2  * gsm - gsm resource for zavai
3  *
4  * Copyright (C) 2009--2010  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 gsm {
25
26 [DBus (name = "org.freesmartphone.GSM.Device")]
27 public interface FSO_GSM_Device : Object {
28     public abstract async int test_int (int i, out int j) throws DBus.Error;
29     public abstract async string test_string (string s, out string t) throws DBus.Error;
30     public abstract async void set_sim_buffers_sms(bool sim_buffers_sms) throws DBus.Error;
31     public abstract async void set_r_t_c() throws DBus.Error;
32     public abstract async void cancel_command() throws DBus.Error;
33     public abstract async void set_antenna_power(bool power) throws DBus.Error;
34     public abstract async GLib.HashTable<string, GLib.Value?> get_info() throws DBus.Error;
35     public abstract async void set_microphone_muted(bool muted) throws DBus.Error;
36     public signal void keypad_event(string name, bool pressed);
37     public abstract async int get_speaker_volume() throws DBus.Error;
38     public abstract async int get_r_t_c() throws DBus.Error;
39     public abstract async void set_speaker_volume(int modem_volume) throws DBus.Error;
40     public abstract async GLib.HashTable<string, GLib.Value?> get_features() throws DBus.Error;
41     public abstract async bool get_microphone_muted() throws DBus.Error;
42     public abstract async bool get_antenna_power() throws DBus.Error;
43     public abstract async void get_power_status(out string param0, out int param1) throws DBus.Error;
44     public abstract async bool get_sim_buffers_sms() throws DBus.Error;
45 }
46
47 [DBus (name = "org.freesmartphone.GSM.SIM")]
48 public interface FSO_GSM_SIM : GLib.Object {
49     //public abstract async SIMParam0Struct[] retrieve_phonebook(string category) throws DBus.Error;
50     public abstract async void send_auth_code(string code) throws DBus.Error;
51     public abstract async string get_issuer() throws DBus.Error;
52     public abstract async void change_auth_code(string old_pin, string new_pin) throws DBus.Error;
53     public signal void auth_status(string status);
54     public abstract async string send_generic_sim_command(string command) throws DBus.Error;
55     public abstract async string[] list_phonebooks() throws DBus.Error;
56     public abstract async void set_service_center_number(string number) throws DBus.Error;
57     public abstract async GLib.HashTable<string, string> get_provider_list() throws DBus.Error;
58     //public abstract async SIMParam0Struct2[] get_home_zones() throws DBus.Error;
59     public signal void ready_status(bool status);
60     public abstract async void retrieve_entry(string category, int index, out string param0, out string param1) throws DBus.Error;
61     public abstract async void delete_message(int index) throws DBus.Error;
62     public abstract async void send_restricted_sim_command(int command, int fileid, int p1, int p2, int p3, string data, out int param0, out int param1, out string param2) throws DBus.Error;
63     public abstract async GLib.HashTable<string, GLib.Value?> get_messagebook_info() throws DBus.Error;
64     public abstract async bool get_sim_ready() throws DBus.Error;
65     public abstract async GLib.HashTable<string, GLib.Value?> get_phonebook_info(string category) throws DBus.Error;
66     public signal void memory_full();
67     public abstract async GLib.HashTable<string, GLib.Value?> get_sim_info() throws DBus.Error;
68     public abstract async void set_auth_code_required(bool required, string pin) throws DBus.Error;
69     public abstract async string get_auth_status() throws DBus.Error;
70     public abstract async void send_stored_message(int index, out int param0, out string param1) throws DBus.Error;
71     public abstract async int store_message(string number, string contents, GLib.HashTable<string, GLib.Value?> properties) throws DBus.Error;
72     public abstract async bool get_auth_code_required() throws DBus.Error;
73     public signal void incoming_stored_message(int index);
74     public abstract async void retrieve_message(int index, out string param0, out string param1, out string param2, out GLib.HashTable<string, GLib.Value?> param3) throws DBus.Error;
75     public abstract async void store_entry(string category, int index, string name, string number) throws DBus.Error;
76     public abstract async void unlock(string puk, string new_pin) throws DBus.Error;
77     public abstract async string get_service_center_number() throws DBus.Error;
78     //public abstract async SIMParam0Struct23[] retrieve_messagebook(string category) throws DBus.Error;
79     public abstract async void delete_entry(string category, int index) throws DBus.Error;
80 }
81
82 [DBus (name = "org.freesmartphone.GSM.Network")]
83 public interface FSO_GSM_Network : GLib.Object {
84     public signal void status(GLib.HashTable<string, GLib.Value?> status);
85     public signal void signal_strength(int strength);
86     //public abstract async NetworkParam0Struct[] list_providers() throws DBus.Error;
87     public abstract async GLib.HashTable<string, GLib.Value?> get_call_forwarding(string reason) throws DBus.Error;
88     public signal void time_zone_report(int timezone);
89     public abstract async void unregister() throws DBus.Error;
90     public abstract async void set_calling_identification(string status) throws DBus.Error;
91     public abstract async void register_() throws DBus.Error;
92     public abstract async void send_ussd_request(string request) throws DBus.Error;
93     public abstract async void disable_call_forwarding(string reason, string class_) throws DBus.Error;
94     public signal void incoming_ussd(string mode, string message_);
95     public abstract async int get_signal_strength() throws DBus.Error;
96     public abstract async void enable_call_forwarding(string reason, string class_, string number, int timeout) throws DBus.Error;
97     public abstract async string get_calling_identification() throws DBus.Error;
98     public abstract async void register_with_provider(string operator_code) throws DBus.Error;
99     public signal void cipher_status(string gsm, string gprs);
100     public abstract async GLib.HashTable<string, GLib.Value?> get_status() throws DBus.Error;
101     public abstract async void get_country_code(out string param0, out string param1) throws DBus.Error;
102 }
103
104 [DBus (name = "org.freesmartphone.GSM.Call")]
105 public interface FSO_GSM_Call : GLib.Object {
106     public abstract async void activate(int index) throws DBus.Error;
107     public abstract async void emergency(string number) throws DBus.Error;
108     public abstract async void hold_active() throws DBus.Error;
109     public abstract async void release_held() throws DBus.Error;
110     public abstract async void send_dtmf(string tones) throws DBus.Error;
111     public abstract async void release_all() throws DBus.Error;
112     public abstract async int initiate(string number, string type_) throws DBus.Error;
113     // public abstract async CallParam0Struct[] list_calls() throws DBus.Error;
114     public abstract async void transfer(string number) throws DBus.Error;
115     public abstract async void release(int index) throws DBus.Error;
116     public signal void call_status(int index, string status, GLib.HashTable<string, GLib.Value?> properties);
117     public abstract async void activate_conference(int index) throws DBus.Error;
118 }
119
120 public class GSM: zavai.ScriptMonitorService
121 {
122     protected dynamic DBus.Object dbus;
123     public FSO_GSM_Device device;
124     public FSO_GSM_Network network;
125     public FSO_GSM_SIM sim;
126     public FSO_GSM_Call call;
127
128     protected class CallInfo
129     {
130         public int gsm_id;
131         public zavai.log.Log log;
132     }
133     protected List<CallInfo> calls;
134
135     public string info_provider;
136     public string info_registration;
137     public int info_signal_strength;
138
139     public signal void status_changed(string message);
140     public signal void info_changed();
141     public signal void new_call(int index);
142     public signal void end_call(int index);
143     public signal void new_sms();
144
145     protected void dump_table(HashTable<string, Value?> vals)
146     {
147         vals.for_each((pk, pv) => {
148             string k = (string)pk;
149             Value? v = (Value?)pv;
150             stderr.printf("K: %s V: %s\n", k, v == null ? "(null)" : v.strdup_contents());
151         });
152     }
153
154     protected void acquire_new_status(HashTable<string, Value?> status)
155     {
156         // NETWORK STATUS
157         // K: provider V: "vodafone UK"
158         // K: mode V: "automatic"
159         // K: registration V: "roaming"
160         // K: cid V: "157F"
161         // K: lac V: "0031"
162         // K: act V: "GSM"
163         // K: code V: "23415"
164         bool changed = false;
165
166         var vprovider = status.lookup("provider");
167         if (vprovider != null)
168         {
169             if (info_provider != vprovider.get_string())
170             {
171                 info_provider = vprovider.get_string();
172                 changed = true;
173             }
174         }
175
176         var vregistration = status.lookup("registration");
177         if (vregistration != null)
178         {
179             if (info_registration != vregistration.get_string())
180             {
181                 info_registration = vregistration.get_string();
182                 changed = true;
183             }
184         }
185
186         if (changed)
187         {
188 stderr.printf("NOTIFY CHANGED\n");
189             info_changed();
190         }
191     }
192
193     protected void acquire_new_signal_strength(int strength)
194     {
195         if (info_signal_strength != strength)
196         {
197             info_signal_strength = strength;
198 stderr.printf("ACQUIRE SIG %d\n", info_signal_strength);
199             info_changed();
200         }
201     }
202
203     public GSM()
204     {
205         Object(name: "gsm");
206
207         calls = new List<CallInfo>();
208
209         device = (FSO_GSM_Device)zavai.registry.sbus.get_object(
210                 "org.freesmartphone.ogsmd", 
211                 "/org/freesmartphone/GSM/Device",
212                 "org.freesmartphone.GSM.Device");
213         network = (FSO_GSM_Network)zavai.registry.sbus.get_object(
214             "org.freesmartphone.ogsmd", 
215             "/org/freesmartphone/GSM/Device",
216             "org.freesmartphone.GSM.Network");
217         sim = (FSO_GSM_SIM)zavai.registry.sbus.get_object(
218                 "org.freesmartphone.ogsmd", 
219                 "/org/freesmartphone/GSM/Device",
220                 "org.freesmartphone.GSM.SIM");
221         call = (FSO_GSM_Call)zavai.registry.sbus.get_object(
222             "org.freesmartphone.ogsmd", 
223             "/org/freesmartphone/GSM/Device",
224             "org.freesmartphone.GSM.Call");
225         dbus = zavai.registry.sbus.get_object(
226                 "org.freedesktop.DBus",
227                 "/org/freedesktop/DBus",
228                 "org.freedesktop.DBus");
229         dbus.NameOwnerChanged += on_name_owner_changed;
230
231         info_provider = "(unknown)";
232         info_signal_strength = -1;
233
234         network.status += (status) => {
235             stderr.printf("NETWORK STATUS\n");
236             dump_table(status);
237             acquire_new_status(status);
238         };
239
240         network.signal_strength += (strength) => {
241             stderr.printf("SIGNAL STRENGTH %d\n", strength);
242             acquire_new_signal_strength(strength);
243         };
244
245         call.call_status += on_call_status;
246         sim.incoming_stored_message += (idx) => {
247             stderr.printf("INCOMING STORED MESSAGE %d\n", idx);
248             sms_log_and_delete(idx);
249         };
250     }
251
252     /// Request GPS resource
253     public override void start()
254     {
255         if (started) return;
256
257         status_changed("Starting");
258
259         script_start();
260
261         base.start();
262     }
263
264     protected void on_name_owner_changed(DBus.Object sender, string name, string oldOwner, string newOwner)
265     {
266         zavai.log.debug("NOC " + name + " from " + oldOwner + " to " + newOwner);
267         if (name == "org.freesmartphone.ogsmd" && newOwner != "")
268         {
269             status_changed("ogpsd came online");
270             start_gsm.begin();
271         }
272     }
273
274     // Release usage of GPS
275     public override void stop()
276     {
277         if (!started) return;
278
279         script_stop();
280
281         status_changed("");
282         info_provider = "";
283         info_signal_strength = -1;
284         info_changed();
285     }
286
287     protected override void cleanup_after_script_stop()
288     {
289         call = null;
290     }
291
292     public async void start_gsm()
293     {
294         status_changed("Turning on antenna");
295         while (true)
296         {
297             try {
298                 yield device.set_antenna_power(true);
299                 break;
300             } catch (Error e) {
301                 zavai.log.warning("SetAntennaPower: " + e.message);
302                 if (e.message.str("current status is 'enabling'") != null
303                  || e.message.str("current status is 'unknown'") != null)
304                 {
305                     status_changed("Waiting for ogsmd to settle");
306                     zavai.log.info("trying again after 2 seconds");
307                     Timeout.add(2 * 1000, () => {
308                         start_gsm.callback();
309                         return false;
310                     });
311                     yield;
312                 } else {
313                     status_changed("Checking if PIN is required");
314                     string status = yield sim.get_auth_status();
315                     zavai.log.info("on_auth_status: " + status);
316                     if (status == "READY")
317                         status_changed("PIN ok");
318                     else if (status == "SIM PIN")
319                     {
320                         status_changed("Sending PIN");
321                         yield sim.send_auth_code(zavai.config.sim_pin);
322                         status_changed("PIN OK");
323                     }
324                     else
325                         zavai.log.debug("Unknown status: " + status);
326                 }
327             }
328         }
329         zavai.log.warning("on_antenna_power ok");
330         status_changed("Registering with network");
331         yield network.register_();
332         status_changed("Registered with network");
333
334         acquire_new_status(yield network.get_status());
335         acquire_new_signal_strength(yield network.get_signal_strength());
336     }
337
338     protected CallInfo? lookup_call(int gsm_id)
339     {
340         for (weak List<CallInfo> i = calls; i != null; i = i.next)
341             if (i.data.gsm_id == gsm_id)
342                 return i.data;
343         return null;
344     }
345
346     public void on_call_status(int index, string status, HashTable<string, Value?> properties)
347     {
348         bool is_new = false;
349         bool is_done = false;
350         stderr.printf("CALL STATUS %d %s\n", index, status);
351         dump_table(properties);
352
353         CallInfo? info = lookup_call(index);
354         if (info == null)
355         {
356             is_new = true;
357             Value? v = properties.lookup("peer");
358             string title;
359             if (v != null)
360                 title = "%s call from %s".printf(status, v.get_string());
361             else
362                 title = "%s call".printf(status);
363
364             info = new CallInfo();
365             info.gsm_id = index;
366             info.log = zavai.log.log.start("call", title);
367             calls.append(info);
368         }
369
370         // Log a summary of all info
371         string call_info = "status: %s\n".printf(status);
372         properties.for_each((pk, pv) => {
373             string k = (string)pk;
374             Value? v = (Value?)pv;
375             call_info = call_info + "%s: %s\n".printf(k, v == null ? "(null)" : v.strdup_contents());
376         });
377         info.log.add(call_info);
378
379         // Remove entry when it's the last possible status
380         if (status == "release")
381         {
382             zavai.log.log.end(info.log);
383             for (weak List<CallInfo> i = calls; i != null; i = i.next)
384                 if (i.data.gsm_id == index)
385                 {
386                     calls.delete_link(i);
387                     break;
388                 }
389             is_done = true;
390         }
391
392         /*
393         dbg("cbCallStatus %d, %s, %s" % (id, status, formatDict(properties)))
394         self.status = status
395         if status == "incoming":
396             if "peer" in properties and properties["peer"] == "+358942832031":
397                 self.gsm_call_iface.ReleaseAll()
398                 os.system("kapula-debug-call-handler &")
399             else:
400                 os.system("alsactl restore -f /etc/alsa-scenarios/stereoout-maxvolume.state")
401                 os.system("vibrator-start")
402                 os.system("ringtone-start")
403                 os.system("ledctrl --on-time 400 --off-time 200 gta02-aux:red");
404         if status == "release":
405             os.system("ringtone-stop")
406             os.system("vibrator-stop")
407             os.system("ledctrl --off gta02-aux:red");
408         */
409
410         if (is_new && !is_done)
411             new_call(index);
412         if (is_done)
413             end_call(index);
414     }
415
416     public async void sms_log_and_delete(int idx)
417     {
418         // Retrieve message info
419         string state, sender, msg;
420         GLib.HashTable<string, GLib.Value?> info;
421         yield sim.retrieve_message(idx, out state, out sender, out msg, out info);
422
423         // Log message info
424         var sms_log = zavai.log.log.start("sms", msg);
425         string sms_info = "state: %s\nsender: %s\nmsg: %s\n".printf(state, sender, msg);
426         info.for_each((pk, pv) => {
427             string k = (string)pk;
428             Value? v = (Value?)pv;
429             sms_info = sms_info + "%s: %s\n".printf(k, v == null ? "(null)" : v.strdup_contents());
430         });
431         sms_log.add(sms_info);
432         zavai.log.log.end(sms_log);
433
434         // Delete message
435         yield sim.delete_message(idx);
436
437         // Notify reception of the sms
438         new_sms();
439     }
440 }
441
442 public class GPRS: zavai.Service
443 {
444     public dynamic DBus.Object device;
445
446     public GPRS()
447     {
448         Object(name: "gsm.gprs");
449
450         device = zavai.registry.sbus.get_object(
451             "org.freesmartphone.ogsmd", 
452             "/org/freesmartphone/GSM/Device",
453             "org.freesmartphone.GSM.PDP");
454     }
455
456     /// Request GPS resource
457     public override void start()
458     {
459         if (started) return;
460         try {
461             //gsm.request(name);
462             device.ActivateContext(
463                 zavai.config.gprs_apn,
464                 zavai.config.gprs_user,
465                 zavai.config.gprs_pass);
466             zavai.log.info("Started GPRS");
467             base.start();
468         } catch (GLib.Error e) {
469             zavai.log.error(e.message);
470         }
471         base.start();
472     }
473
474     // Release usage of GPS
475     public override void stop()
476     {
477         if (!started) return;
478         try {
479             //gsm.release(name);
480             device.DeactivateContext();
481             zavai.log.info("Stopped GPRS");
482             base.stop();
483         } catch (GLib.Error e) {
484             zavai.log.error(e.message);
485         }
486         base.stop();
487     }
488 }
489
490 public zavai.gsm.GSM gsm = null;
491 public zavai.gsm.GPRS gprs = null;
492
493 public void init()
494 {
495     gsm = new GSM();
496     gprs = new GPRS();
497 }
498
499 }
500 }