← Back to branch summary

~noskcaj/ubuntu/saucy/sflphone/merge-1.2.3-2

« back to all changes in this revision

Viewing changes to gnome/src/dbus/dbus.h

  • Committer: Package Import Robot
  • Author(s): Francois Marier
  • Date: 2012-02-18 21:47:09 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120218214709-6362d71gqdsdkrj5
Tags: 1.0.2-1
http://bugs.debian.org/658987
* New upstream release
  - remove logging patch (applied upstream)
  - update s390 patch since it was partially applied upstream
* Include the Evolution plugin as a separate binary package

* Fix compilation issues on SH4 (closes: #658987)
* Merge Ubuntu's binutils-gold linking fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome/src/dbus/dbus.h
30
30
 *  as that of the covered work.
31
31
 */
32
32
 
33
 
#ifndef __DBUS_H__
34
 
#define __DBUS_H__
 
33
#ifndef DBUS_H_
 
34
#define DBUS_H_
35
35
 
36
36
#include <dbus/dbus-glib.h>
37
37
 
49
49
 * Try to connect to DBus services
50
50
 * @return TRUE if connection succeeded, FALSE otherwise
51
51
 */
52
 
gboolean dbus_connect (GError **error);
 
52
gboolean dbus_connect(GError **error);
53
53
 
54
54
/**
55
55
 * Unreferences the proxies
56
56
 */
57
 
void dbus_clean ();
 
57
void dbus_clean();
58
58
 
59
59
/**
60
60
 * CallManager - Hold a call
61
61
 * @param c The call to hold
62
62
 */
63
 
void dbus_hold (const callable_obj_t * c);
 
63
void dbus_hold(const callable_obj_t *c);
64
64
 
65
65
/**
66
66
 * CallManager - Unhold a call
67
67
 * @param c The call to unhold
68
68
 */
69
 
void dbus_unhold (const callable_obj_t * c);
 
69
void dbus_unhold(const callable_obj_t *c);
70
70
 
71
71
/**
72
72
 * CallManager - Hang up a call
73
73
 * @param c The call to hang up
74
74
 */
75
 
void dbus_hang_up (const callable_obj_t * c);
 
75
void dbus_hang_up(const callable_obj_t *c);
76
76
 
77
77
/**
78
78
 * CallManager - Transfer a call
79
79
 * @param c The call to transfer
80
80
 */
81
 
void dbus_transfer (const callable_obj_t * c);
 
81
void dbus_transfer(const callable_obj_t *c);
82
82
 
83
83
/**
84
84
 * CallManager - Perform an attended transfer on two calls
91
91
 * CallManager - Accept a call
92
92
 * @param c The call to accept
93
93
 */
94
 
void dbus_accept (const callable_obj_t * c);
 
94
void dbus_accept(const callable_obj_t *c);
95
95
 
96
96
/**
97
97
 * CallManager - Refuse a call
98
98
 * @param c The call to refuse
99
99
 */
100
 
void dbus_refuse (const callable_obj_t * c);
 
100
void dbus_refuse(const callable_obj_t *c);
101
101
 
102
102
/**
103
103
 * CallManager - Place a call
104
104
 * @param c The call to place
105
105
 */
106
 
void dbus_place_call (const callable_obj_t * c);
 
106
void dbus_place_call(const callable_obj_t *c);
107
107
 
108
108
 
109
109
/**
110
110
 * ConfigurationManager - Get the list of the setup accounts
111
111
 * @return gchar** The list of accounts
112
112
 */
113
 
gchar ** dbus_account_list();
 
113
gchar **dbus_account_list();
114
114
 
115
115
/**
116
116
 * ConfigurationManager - Get the details of a specific account
117
117
 * @param accountID The unique of the account
118
118
 * @return GHashTable* The details of the account
119
119
 */
120
 
GHashTable * dbus_get_account_details (gchar * accountID);
 
120
GHashTable *dbus_get_account_details(const gchar *accountID);
121
121
 
122
122
/**
123
123
 * ConfigurationManager - Set the details of a specific account
124
124
 * @param a The account to update
125
125
 */
126
 
void dbus_set_account_details (account_t *a);
127
 
 
128
 
/**
129
 
 * ConfigurationManager - Set the additional credential information
130
 
 * of a specific account.
131
 
 * This function will add the new section on the server side
132
 
 * if it cannot be found.
133
 
 * @param a The account to update
134
 
 */
135
 
void dbus_set_credentials (account_t *a);
136
 
 
137
 
/**
138
 
 * ConfigurationManager - Set the additional credential information
139
 
 * of a specific account.
140
 
 * This function will add the new section on the server side
141
 
 * if it cannot be found.
142
 
 * @param a The account to update
143
 
 */
144
 
void dbus_get_credentials (account_t *a);
 
126
void dbus_set_account_details(account_t *a);
 
127
 
 
128
/**
 
129
 * ConfigurationManager - Set the additional credential information
 
130
 * of a specific account.
 
131
 * This function will add the new section on the server side
 
132
 * if it cannot be found.
 
133
 * @param a The account to update
 
134
 */
 
135
void dbus_set_credentials(account_t *a);
 
136
 
 
137
/**
 
138
 * ConfigurationManager - Set the additional credential information
 
139
 * of a specific account.
 
140
 * This function will add the new section on the server side
 
141
 * if it cannot be found.
 
142
 * @param a The account to update
 
143
 */
 
144
void dbus_get_credentials(account_t *a);
145
145
 
146
146
/**
147
147
 * ConfigurationManager - Get the details for the ip2ip profile
148
148
 */
149
 
GHashTable * dbus_get_ip2_ip_details (void);
 
149
GHashTable *dbus_get_ip2_ip_details(void);
150
150
 
151
151
/**
152
152
 * ConfigurationManager - Send registration request
155
155
 *               0 for unregistration request
156
156
 *               1 for registration request
157
157
 */
158
 
void dbus_send_register (gchar* accountID , const guint enable);
 
158
void dbus_send_register(const gchar *accountID, gboolean enable);
159
159
 
160
160
/**
161
161
 * ConfigurationManager - Add an account to the list
162
162
 * @param a The account to add
163
163
 */
164
 
void dbus_add_account (account_t *a);
 
164
void dbus_add_account(account_t *a);
165
165
 
166
166
/**
167
167
 * ConfigurationManager - Remove an account from the list
168
168
 * @param accountID The account to remove
169
169
 */
170
 
void dbus_remove_account (gchar * accountID);
 
170
void dbus_remove_account(const gchar *accountID);
171
171
 
172
172
/**
173
173
 * ConfigurationManager - Set volume for speaker/mic
174
174
 * @param device The speaker or the mic
175
175
 * @param value The new value
176
176
 */
177
 
void dbus_set_volume (const gchar * device, gdouble value);
 
177
void dbus_set_volume(const gchar *device, gdouble value);
178
178
 
179
179
/**
180
180
 * ConfigurationManager - Get the volume of a device
181
181
 * @param device The speaker or the mic
182
182
 */
183
 
gdouble dbus_get_volume (const gchar * device);
 
183
gdouble dbus_get_volume(const gchar *device);
184
184
 
185
185
/**
186
186
 * ConfigurationManager - Play DTMF
187
187
 * @param key The DTMF to send
188
188
 */
189
 
void dbus_play_dtmf (const gchar * key);
 
189
void dbus_play_dtmf(const gchar *key);
190
190
 
191
191
/**
192
192
 * ConfigurationManager - Get the audio codecs list
199
199
 * @param payload The payload of the audio codec
200
200
 * @return gchar** The audio codec details
201
201
 */
202
 
gchar** dbus_audio_codec_details (int payload);
 
202
gchar **dbus_audio_codec_details(int payload);
203
203
 
204
204
/**
205
205
 * ConfigurationManager - Get the default audio codec list
206
206
 * The default audio codec list are the audio codecs selected by the server if the user hasn't made any changes
207
207
 * @return gchar** The default audio codec list
208
208
 */
209
 
gchar** dbus_default_audio_codec_list();
 
209
gchar **dbus_default_audio_codec_list();
210
210
 
211
211
/**
212
212
 * ConfigurationManager - Get the list of the audio codecs used for media negotiation
213
213
 * @return The list of audio codecs
214
214
 */
215
 
GArray *dbus_get_active_audio_codec_list (gchar *accountID);
 
215
GArray *dbus_get_active_audio_codec_list(const gchar *accountID);
216
216
 
217
217
/**
218
218
 * ConfigurationManager - Set the list of audio codecs used for media negociation
219
219
 * @param list The list of audio codecs
220
220
 */
221
 
void dbus_set_active_audio_codec_list (const gchar** list, const gchar*);
 
221
void dbus_set_active_audio_codec_list(const gchar **list, const gchar *);
222
222
 
223
223
/**
224
224
 * CallManager - return the audio codec name
225
225
 * @param callable_obj_t* current call
226
226
 */
227
 
gchar* dbus_get_current_audio_codec_name (const callable_obj_t * c);
 
227
gchar *dbus_get_current_audio_codec_name(const callable_obj_t *c);
228
228
 
229
229
/**
230
230
 * ConfigurationManager - Get the list of available output audio plugins
231
231
 * @return gchar** The list of plugins
232
232
 */
233
 
gchar** dbus_get_audio_plugin_list();
 
233
gchar **dbus_get_audio_plugin_list();
234
234
 
235
235
 
236
236
/**
237
237
 * ConfigurationManager - Select an input audio plugin
238
238
 * @param audioPlugin The string description of the plugin
239
239
 */
240
 
void dbus_set_audio_plugin (gchar* audioPlugin);
 
240
void dbus_set_audio_plugin(const gchar *audioPlugin);
241
241
 
242
242
/**
243
243
 * ConfigurationManager - Get the list of available output audio devices
244
244
 * @return gchar** The list of devices
245
245
 */
246
 
gchar** dbus_get_audio_output_device_list();
 
246
gchar **dbus_get_audio_output_device_list();
247
247
 
248
248
/**
249
249
 * ConfigurationManager - Select an output audio device
250
250
 * @param index The index of the soundcard
251
251
 */
252
 
void dbus_set_audio_output_device (const int index);
 
252
void dbus_set_audio_output_device(int index);
253
253
 
254
254
/**
255
255
 * ConfigurationManager - Get the list of available input audio devices
256
256
 * @return gchar** The list of devices
257
257
 */
258
 
gchar** dbus_get_audio_input_device_list();
 
258
gchar **dbus_get_audio_input_device_list();
259
259
 
260
260
/**
261
261
 * ConfigurationManager - Select an input audio device
262
262
 * @param index The index of the soundcard
263
263
 */
264
 
void dbus_set_audio_input_device (const int index);
 
264
void dbus_set_audio_input_device(int index);
265
265
 
266
266
/**
267
267
 * ConfigurationManager - Get the current audio devices
268
268
 * @return gchar** The index of the current soundcard
269
269
 */
270
 
gchar** dbus_get_current_audio_devices_index();
 
270
gchar **dbus_get_current_audio_devices_index();
271
271
 
272
272
/**
273
273
 * ConfigurationManager - Get the index of the specified audio device
274
274
 * @param name The string description of the audio device
275
275
 * @return int The index of the device
276
276
 */
277
 
int dbus_get_audio_device_index (const gchar* name);
 
277
int dbus_get_audio_device_index(const gchar *name);
278
278
 
279
279
/**
280
280
 * ConfigurationManager - Get the current output audio plugin
283
283
 *                plughw
284
284
 *                dmix
285
285
 */
286
 
gchar* dbus_get_current_audio_output_plugin();
 
286
gchar *dbus_get_current_audio_output_plugin();
287
287
 
288
288
/**
289
289
 * ConfigurationManager - Get the current noise suppressor state
290
290
 * @return gchar* The state (enabled/disabled)
291
291
 */
292
 
gchar *dbus_get_noise_suppress_state (void);
 
292
gchar *dbus_get_noise_suppress_state(void);
293
293
 
294
294
/**
295
295
 * ConfigurationManager - Set the current noise suppressor state
296
296
 * @param gchar* The state (enabled/disabled)
297
297
 */
298
 
void dbus_set_noise_suppress_state (gchar *state);
 
298
void dbus_set_noise_suppress_state(const gchar *state);
299
299
 
300
300
/**
301
301
 * ConfigurationManager - Get the current echo cancel state
307
307
 * ConfigurationManager - Set the current echo cancel state
308
308
 * @param gchar* The state (enabled/disabled)
309
309
 */
310
 
void dbus_set_echo_cancel_state(gchar *state);
 
310
void dbus_set_echo_cancel_state(const gchar *state);
311
311
 
312
312
int dbus_get_echo_cancel_tail_length(void);
313
313
 
322
322
 * @return int 1 if IAX2 is enabled
323
323
 *             0 otherwise
324
324
 */
325
 
int dbus_is_iax2_enabled (void);
 
325
int dbus_is_iax2_enabled(void);
326
326
 
327
327
/**
328
328
 * ConfigurationManager - Gives the maximum number of days the user wants to have in the history
329
329
 * @return double The maximum number of days
330
330
 */
331
 
guint dbus_get_history_limit (void);
 
331
guint dbus_get_history_limit(void);
332
332
 
333
333
/**
334
334
 * ConfigurationManager - Gives the maximum number of days the user wants to have in the history
335
335
 */
336
 
void dbus_set_history_limit (const guint days);
 
336
void dbus_set_history_limit(guint days);
337
337
 
338
338
/**
339
339
 * ConfigurationManager - Returns the selected audio manager
340
340
 * @return "alsa"
341
341
 *              or "pulseaudio"
342
342
 */
343
 
gchar *dbus_get_audio_manager (void);
 
343
gchar *dbus_get_audio_manager(void);
344
344
 
345
345
/**
346
346
 * ConfigurationManager - Set the audio manager
347
347
 * @param api   "alsa"
348
348
 *              "pulseaudio"
349
349
 */
350
 
void dbus_set_audio_manager (const gchar *api);
 
350
void dbus_set_audio_manager(const gchar *api);
351
351
 
352
352
/**
353
353
 * ConfigurationManager - Start a tone when a new call is open and no numbers have been dialed
356
356
 * @param type  TONE_WITH_MESSAGE
357
357
 *              TONE_WITHOUT_MESSAGE
358
358
 */
359
 
void dbus_start_tone (const int start , const guint type);
 
359
void dbus_start_tone(int start, guint type);
360
360
 
361
361
/**
362
362
 * Instance - Send registration request to dbus service.
365
365
 * @param name The string description of the client. Here : GTK+ Client
366
366
 * @param error return location for a GError or NULL
367
367
 */
368
 
gboolean dbus_register (int pid, gchar * name, GError **error);
 
368
gboolean dbus_register(int pid, const gchar *name, GError **error);
369
369
 
370
370
/**
371
371
 * Instance - Send unregistration request to dbus services
372
372
 * @param pid The pid of the processus
373
373
 */
374
 
void dbus_unregister (int pid);
375
 
 
376
 
void dbus_set_sip_address (const gchar* address);
377
 
 
378
 
gint dbus_get_sip_address (void);
 
374
void dbus_unregister(int pid);
 
375
 
 
376
void dbus_set_sip_address(const gchar *address);
 
377
 
 
378
gint dbus_get_sip_address(void);
379
379
 
380
380
 
381
381
/**
382
382
 * Add a participant (callID) to this conference (confID)
383
383
 */
384
 
void dbus_add_participant (const gchar* callID, const gchar* confID);
 
384
void dbus_add_participant(const gchar *callID, const gchar *confID);
385
385
 
386
386
/**
387
387
 * Return a list of participant for this conference (confID)
388
388
 */
389
 
gchar** dbus_get_participant_list (const gchar *confID);
 
389
gchar **dbus_get_participant_list(const gchar *confID);
390
390
 
391
391
/**
392
392
 * Toggle recording for this instance, may be call or conference
393
393
 */
394
 
void dbus_set_record (const gchar * id);
 
394
void dbus_set_record(const gchar *id);
395
395
 
396
396
/**
397
397
 * Set the path where the recorded audio files will be stored
398
398
 */
399
 
void dbus_set_record_path (const gchar *path);
 
399
void dbus_set_record_path(const gchar *path);
400
400
 
401
401
/**
402
402
 * Get the path where the recorded audio files are stored
403
403
 */
404
 
gchar* dbus_get_record_path (void);
 
404
gchar *dbus_get_record_path(void);
405
405
 
406
406
/**
407
407
 * Set the always recording functionality, once true all call
419
419
 * Encapsulate all the address book-related configuration
420
420
 * Get the configuration
421
421
 */
422
 
GHashTable* dbus_get_addressbook_settings (void);
 
422
GHashTable* dbus_get_addressbook_settings(void);
423
423
 
424
424
/**
425
425
 * Encapsulate all the address book-related configuration
426
426
 * Set the configuration
427
427
 */
428
 
void dbus_set_addressbook_settings (GHashTable *);
429
 
 
430
 
gchar** dbus_get_addressbook_list (void);
431
 
 
432
 
void dbus_set_addressbook_list (const gchar** list);
 
428
void dbus_set_addressbook_settings(GHashTable *);
 
429
 
 
430
gchar **dbus_get_addressbook_list(void);
 
431
 
 
432
void dbus_set_addressbook_list(const gchar **list);
433
433
 
434
434
/**
435
435
 * Resolve the local address given an interface name
436
436
 */
437
 
gchar * dbus_get_address_from_interface_name (gchar* interface);
 
437
gchar * dbus_get_address_from_interface_name(const gchar *interface);
438
438
 
439
439
/**
440
440
 * Query the daemon to return a list of network interface (described as there IP address)
441
441
 */
442
 
gchar** dbus_get_all_ip_interface (void);
 
442
gchar **dbus_get_all_ip_interface(void);
443
443
 
444
444
/**
445
445
 * Query the daemon to return a list of network interface (described as there name)
446
446
 */
447
 
gchar** dbus_get_all_ip_interface_by_name (void);
 
447
gchar **dbus_get_all_ip_interface_by_name(void);
448
448
 
449
449
/**
450
450
 * Encapsulate all the url hook-related configuration
451
451
 * Get the configuration
452
452
 */
453
 
GHashTable* dbus_get_hook_settings (void);
 
453
GHashTable* dbus_get_hook_settings(void);
454
454
 
455
455
/**
456
456
 * Encapsulate all the url hook-related configuration
457
457
 * Set the configuration
458
458
 */
459
 
void dbus_set_hook_settings (GHashTable *);
460
 
 
461
 
 
462
 
gboolean dbus_get_is_recording (const callable_obj_t *);
463
 
 
464
 
GHashTable* dbus_get_call_details (const gchar* callID);
465
 
 
466
 
gchar** dbus_get_call_list (void);
467
 
 
468
 
GHashTable* dbus_get_conference_details (const gchar* confID);
469
 
 
470
 
gchar** dbus_get_conference_list (void);
471
 
 
472
 
void dbus_set_accounts_order (const gchar* order);
473
 
 
474
 
/**
475
 
 * Get a list of serialized hisotry entries
476
 
 * @return The list of history entries
477
 
 */
478
 
gchar **dbus_get_history (void);
479
 
 
480
 
/**
481
 
 * Set the history entries into the daemon. The daemon then write teh content 
482
 
 * of this list into the history file
483
 
 * @param A list of serialized history entries
484
 
 */
485
 
void dbus_set_history (gchar **);
486
 
 
487
 
void sflphone_display_transfer_status (const gchar* message);
 
459
void dbus_set_hook_settings(GHashTable *);
 
460
 
 
461
 
 
462
gboolean dbus_get_is_recording(const callable_obj_t *);
 
463
 
 
464
GHashTable *dbus_get_call_details(const gchar *callID);
 
465
 
 
466
gchar **dbus_get_call_list(void);
 
467
 
 
468
GHashTable* dbus_get_conference_details(const gchar *confID);
 
469
 
 
470
gchar **dbus_get_conference_list(void);
 
471
 
 
472
void dbus_set_accounts_order(const gchar *order);
 
473
 
 
474
/**
 
475
 * Get a the history
 
476
 * @return The PtrArray of history entries
 
477
 */
 
478
GPtrArray *dbus_get_history(void);
 
479
 
 
480
void dbus_clear_history(void);
 
481
 
 
482
void sflphone_display_transfer_status(const gchar *message);
488
483
 
489
484
/**
490
485
 * CallManager - Confirm Short Authentication String
491
486
 * for a given callId
492
487
 * @param c The call to confirm SAS
493
488
 */
494
 
void dbus_confirm_sas (const callable_obj_t * c);
 
489
void dbus_confirm_sas(const callable_obj_t *c);
495
490
 
496
491
/**
497
492
 * CallManager - Reset Short Authentication String
498
493
 * for a given callId
499
494
 * @param c The call to reset SAS
500
495
 */
501
 
void dbus_reset_sas (const callable_obj_t * c);
 
496
void dbus_reset_sas(const callable_obj_t *c);
502
497
 
503
498
/**
504
499
 * CallManager - Request Go Clear in the ZRTP Protocol
505
500
 * for a given callId
506
501
 * @param c The call that we want to go clear
507
502
 */
508
 
void dbus_request_go_clear (const callable_obj_t * c);
 
503
void dbus_request_go_clear(const callable_obj_t *c);
509
504
 
510
505
/**
511
506
 * CallManager - Accept Go Clear request from remote
512
507
 * for a given callId
513
508
 * @param c The call to confirm
514
509
 */
515
 
void dbus_set_confirm_go_clear (const callable_obj_t * c);
 
510
void dbus_set_confirm_go_clear(const callable_obj_t *c);
516
511
 
517
512
/**
518
513
 * CallManager - Get the list of supported TLS methods from
519
514
 * the server in textual form.
520
515
 * @return an array of string representing supported methods
521
516
 */
522
 
gchar** dbus_get_supported_tls_method();
523
 
 
524
 
GHashTable* dbus_get_shortcuts (void);
525
 
 
526
 
void dbus_set_shortcuts (GHashTable * shortcuts);
527
 
 
528
 
void dbus_set_audio_ringtone_device (const int index);
529
 
 
530
 
void
531
 
dbus_hang_up_conference (const conference_obj_t * c);
532
 
 
533
 
void
534
 
dbus_hold_conference (const conference_obj_t * c);
535
 
 
536
 
void
537
 
dbus_unhold_conference (const conference_obj_t * c);
538
 
 
539
 
void
540
 
dbus_detach_participant (const gchar* callID);
541
 
 
542
 
void
543
 
dbus_join_participant (const gchar* sel_callID, const gchar* drag_callID);
 
517
gchar **dbus_get_supported_tls_method();
 
518
 
 
519
GHashTable* dbus_get_shortcuts(void);
 
520
 
 
521
void dbus_set_shortcuts(GHashTable *shortcuts);
 
522
 
 
523
void dbus_set_audio_ringtone_device(int index);
 
524
 
 
525
void
 
526
dbus_hang_up_conference(const conference_obj_t *c);
 
527
 
 
528
void
 
529
dbus_hold_conference(const conference_obj_t *c);
 
530
 
 
531
void
 
532
dbus_unhold_conference(const conference_obj_t *c);
 
533
 
 
534
void
 
535
dbus_detach_participant(const gchar *callID);
 
536
 
 
537
void
 
538
dbus_join_participant(const gchar *sel_callID, const gchar *drag_callID);
544
539
 
545
540
void
546
541
dbus_create_conf_from_participant_list(const gchar **list);
547
542
 
548
543
void
549
 
dbus_join_conference (const gchar* sel_confID, const gchar* drag_confID);
 
544
dbus_join_conference(const gchar *sel_confID, const gchar *drag_confID);
550
545
 
551
546
void
552
 
dbus_add_main_participant (const gchar* confID);
 
547
dbus_add_main_participant(const gchar *confID);
553
548
 
554
549
/* Instant messaging */
555
 
void dbus_send_text_message (const gchar* callID, const gchar *message);
 
550
void dbus_send_text_message(const gchar *callID, const gchar *message);
556
551
 
557
552
/**
558
553
 * Start playback of a recorded