← Back to branch summary

~ubuntu-branches/ubuntu/maverick/empathy/maverick-201208312044

« back to all changes in this revision

Viewing changes to libempathy/empathy-dispatch-operation.c

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville
  • Date: 2009-03-11 01:28:38 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (6.4.1 sid) (1.6.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 48.
  • Revision ID: james.westby@ubuntu.com-20090311012838-tlho02vbsl8p0v9i
Tags: upstream-2.25.92
Import upstream version 2.25.92

Show diffs side-by-side

added added

removed removed

Lines of Context:
libempathy/empathy-dispatch-operation.c
 
1
/*
 
2
 * empathy-dispatch-operation.c - Source for EmpathyDispatchOperation
 
3
 * Copyright (C) 2008 Collabora Ltd.
 
4
 * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
 
5
 *
 
6
 * This library is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU Lesser General Public
 
8
 * License as published by the Free Software Foundation; either
 
9
 * version 2.1 of the License, or (at your option) any later version.
 
10
 *
 
11
 * This library 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 GNU
 
14
 * Lesser General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU Lesser General Public
 
17
 * License along with this library; if not, write to the Free Software
 
18
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
 */
 
20
 
 
21
 
 
22
#include <stdio.h>
 
23
#include <stdlib.h>
 
24
 
 
25
#include "empathy-dispatch-operation.h"
 
26
#include <libempathy/empathy-enum-types.h>
 
27
#include <libempathy/empathy-tp-chat.h>
 
28
#include <libempathy/empathy-tp-call.h>
 
29
#include <libempathy/empathy-tp-file.h>
 
30
 
 
31
#include "empathy-marshal.h"
 
32
 
 
33
#include "extensions/extensions.h"
 
34
 
 
35
#define DEBUG_FLAG EMPATHY_DEBUG_DISPATCHER
 
36
#include <libempathy/empathy-debug.h>
 
37
 
 
38
G_DEFINE_TYPE(EmpathyDispatchOperation, empathy_dispatch_operation,
 
39
  G_TYPE_OBJECT)
 
40
 
 
41
static void empathy_dispatch_operation_set_status (
 
42
  EmpathyDispatchOperation *self, EmpathyDispatchOperationState status);
 
43
static void empathy_dispatch_operation_channel_ready_cb (TpChannel *channel,
 
44
  const GError *error, gpointer user_data);
 
45
 
 
46
/* signal enum */
 
47
enum
 
48
{
 
49
    /* Ready for dispatching */
 
50
    READY,
 
51
    /* Approved by an approver, can only happens on incoming operations */
 
52
    APPROVED,
 
53
    /* Claimed by a handler */
 
54
    CLAIMED,
 
55
    /* Error, channel went away, inspecting it failed etc */
 
56
    INVALIDATED,
 
57
    LAST_SIGNAL
 
58
};
 
59
 
 
60
static guint signals[LAST_SIGNAL] = {0};
 
61
 
 
62
/* properties */
 
63
enum {
 
64
  PROP_CONNECTION = 1,
 
65
  PROP_CHANNEL,
 
66
  PROP_CHANNEL_WRAPPER,
 
67
  PROP_CONTACT,
 
68
  PROP_INCOMING,
 
69
  PROP_STATUS,
 
70
};
 
71
 
 
72
/* private structure */
 
73
typedef struct _EmpathyDispatchOperationPriv \
 
74
  EmpathyDispatchOperationPriv;
 
75
 
 
76
struct _EmpathyDispatchOperationPriv
 
77
{
 
78
  gboolean dispose_has_run;
 
79
  TpConnection *connection;
 
80
  TpChannel *channel;
 
81
  GObject *channel_wrapper;
 
82
  EmpathyContact *contact;
 
83
  EmpathyDispatchOperationState status;
 
84
  gboolean incoming;
 
85
  gboolean approved;
 
86
  gulong invalidated_handler;
 
87
  gulong ready_handler;
 
88
};
 
89
 
 
90
#define GET_PRIV(o)  \
 
91
  (G_TYPE_INSTANCE_GET_PRIVATE ((o), EMPATHY_TYPE_DISPATCH_OPERATION, \
 
92
    EmpathyDispatchOperationPriv))
 
93
 
 
94
static void
 
95
empathy_dispatch_operation_init (EmpathyDispatchOperation *obj)
 
96
{
 
97
  //EmpathyDispatchOperationPriv *priv =
 
98
  //  GET_PRIV (obj);
 
99
 
 
100
  /* allocate any data required by the object here */
 
101
}
 
102
 
 
103
static void empathy_dispatch_operation_dispose (GObject *object);
 
104
static void empathy_dispatch_operation_finalize (GObject *object);
 
105
 
 
106
static void
 
107
empathy_dispatch_operation_set_property (GObject *object,
 
108
  guint property_id, const GValue *value, GParamSpec *pspec)
 
109
{
 
110
  EmpathyDispatchOperation *operation = EMPATHY_DISPATCH_OPERATION (object);
 
111
  EmpathyDispatchOperationPriv *priv = GET_PRIV (operation);
 
112
 
 
113
  switch (property_id)
 
114
    {
 
115
      case PROP_CONNECTION:
 
116
        priv->connection = g_value_dup_object (value);
 
117
        break;
 
118
      case PROP_CHANNEL:
 
119
        priv->channel = g_value_dup_object (value);
 
120
        break;
 
121
      case PROP_CHANNEL_WRAPPER:
 
122
        priv->channel_wrapper = g_value_dup_object (value);
 
123
        break;
 
124
      case PROP_CONTACT:
 
125
        if (priv->contact != NULL)
 
126
          g_object_unref (priv->contact);
 
127
        priv->contact = g_value_dup_object (value);
 
128
        break;
 
129
      case PROP_INCOMING:
 
130
        priv->incoming = g_value_get_boolean (value);
 
131
        break;
 
132
    }
 
133
}
 
134
 
 
135
static void
 
136
empathy_dispatch_operation_get_property (GObject *object,
 
137
  guint property_id, GValue *value, GParamSpec *pspec)
 
138
{
 
139
  EmpathyDispatchOperation *operation = EMPATHY_DISPATCH_OPERATION (object);
 
140
  EmpathyDispatchOperationPriv *priv = GET_PRIV (operation);
 
141
 
 
142
  switch (property_id)
 
143
    {
 
144
      case PROP_CONNECTION:
 
145
        g_value_set_object (value, priv->connection);
 
146
        break;
 
147
      case PROP_CHANNEL:
 
148
        g_value_set_object (value, priv->channel);
 
149
        break;
 
150
      case PROP_CHANNEL_WRAPPER:
 
151
        g_value_set_object (value, priv->channel_wrapper);
 
152
        break;
 
153
      case PROP_CONTACT:
 
154
        g_value_set_object (value, priv->contact);
 
155
        break;
 
156
      case PROP_INCOMING:
 
157
        g_value_set_boolean (value, priv->incoming);
 
158
        break;
 
159
      case PROP_STATUS:
 
160
        g_value_set_enum (value, priv->status);
 
161
        break;
 
162
    }
 
163
}
 
164
 
 
165
static void
 
166
empathy_dispatch_operation_invalidated (TpProxy *proxy, guint domain,
 
167
  gint code, char *message, EmpathyDispatchOperation *self)
 
168
{
 
169
  empathy_dispatch_operation_set_status (self,
 
170
    EMPATHY_DISPATCHER_OPERATION_STATE_INVALIDATED);
 
171
 
 
172
  g_signal_emit (self, signals[INVALIDATED], 0, domain, code, message);
 
173
}
 
174
 
 
175
static void
 
176
empathy_dispatch_operation_constructed (GObject *object)
 
177
{
 
178
  EmpathyDispatchOperation *self = EMPATHY_DISPATCH_OPERATION (object);
 
179
  EmpathyDispatchOperationPriv *priv = GET_PRIV (self);
 
180
 
 
181
  empathy_dispatch_operation_set_status (self,
 
182
    EMPATHY_DISPATCHER_OPERATION_STATE_PREPARING);
 
183
 
 
184
  priv->invalidated_handler =
 
185
    g_signal_connect (priv->channel, "invalidated",
 
186
      G_CALLBACK (empathy_dispatch_operation_invalidated), self);
 
187
 
 
188
  tp_channel_call_when_ready (priv->channel,
 
189
    empathy_dispatch_operation_channel_ready_cb, self);
 
190
}
 
191
 
 
192
static void
 
193
empathy_dispatch_operation_class_init (
 
194
  EmpathyDispatchOperationClass *empathy_dispatch_operation_class)
 
195
{
 
196
  GObjectClass *object_class =
 
197
    G_OBJECT_CLASS (empathy_dispatch_operation_class);
 
198
  GParamSpec *param_spec;
 
199
 
 
200
  g_type_class_add_private (empathy_dispatch_operation_class,
 
201
    sizeof (EmpathyDispatchOperationPriv));
 
202
 
 
203
  object_class->set_property = empathy_dispatch_operation_set_property;
 
204
  object_class->get_property = empathy_dispatch_operation_get_property;
 
205
 
 
206
  object_class->dispose = empathy_dispatch_operation_dispose;
 
207
  object_class->finalize = empathy_dispatch_operation_finalize;
 
208
  object_class->constructed = empathy_dispatch_operation_constructed;
 
209
 
 
210
  signals[READY] = g_signal_new ("ready",
 
211
    G_OBJECT_CLASS_TYPE(empathy_dispatch_operation_class),
 
212
      G_SIGNAL_RUN_LAST,
 
213
      0,
 
214
      NULL, NULL,
 
215
      g_cclosure_marshal_VOID__VOID,
 
216
      G_TYPE_NONE, 0);
 
217
 
 
218
  signals[APPROVED] = g_signal_new ("approved",
 
219
    G_OBJECT_CLASS_TYPE(empathy_dispatch_operation_class),
 
220
      G_SIGNAL_RUN_LAST,
 
221
      0,
 
222
      NULL, NULL,
 
223
      g_cclosure_marshal_VOID__VOID,
 
224
      G_TYPE_NONE, 0);
 
225
 
 
226
  signals[CLAIMED] = g_signal_new ("claimed",
 
227
    G_OBJECT_CLASS_TYPE(empathy_dispatch_operation_class),
 
228
      G_SIGNAL_RUN_LAST,
 
229
      0,
 
230
      NULL, NULL,
 
231
      g_cclosure_marshal_VOID__VOID,
 
232
      G_TYPE_NONE, 0);
 
233
 
 
234
  signals[INVALIDATED] = g_signal_new ("invalidated",
 
235
    G_OBJECT_CLASS_TYPE(empathy_dispatch_operation_class),
 
236
      G_SIGNAL_RUN_LAST,
 
237
      0,
 
238
      NULL, NULL,
 
239
      _empathy_marshal_VOID__UINT_INT_STRING,
 
240
      G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_INT, G_TYPE_STRING);
 
241
 
 
242
  param_spec = g_param_spec_object ("connection",
 
243
    "connection", "The telepathy connection",
 
244
    TP_TYPE_CONNECTION,
 
245
    G_PARAM_CONSTRUCT_ONLY |
 
246
    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
247
  g_object_class_install_property (object_class, PROP_CONNECTION,
 
248
                                  param_spec);
 
249
 
 
250
  param_spec = g_param_spec_object ("channel",
 
251
    "channel", "The telepathy channel",
 
252
    TP_TYPE_CHANNEL,
 
253
    G_PARAM_CONSTRUCT_ONLY |
 
254
    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
255
  g_object_class_install_property (object_class, PROP_CHANNEL,
 
256
                                  param_spec);
 
257
 
 
258
  param_spec = g_param_spec_object ("channel-wrapper",
 
259
    "channel wrapper", "The empathy specific channel wrapper",
 
260
    G_TYPE_OBJECT,
 
261
    G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
262
  g_object_class_install_property (object_class, PROP_CHANNEL_WRAPPER,
 
263
                                  param_spec);
 
264
 
 
265
  param_spec = g_param_spec_object ("contact",
 
266
    "contact", "The empathy contact",
 
267
    EMPATHY_TYPE_CONTACT,
 
268
    G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
269
  g_object_class_install_property (object_class, PROP_CONTACT,
 
270
                                  param_spec);
 
271
 
 
272
  param_spec = g_param_spec_boolean ("incoming",
 
273
    "incoming", "Whether or not the channel is incoming",
 
274
    FALSE,
 
275
    G_PARAM_CONSTRUCT_ONLY |
 
276
    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
277
  g_object_class_install_property (object_class, PROP_INCOMING,
 
278
                                  param_spec);
 
279
 
 
280
  param_spec = g_param_spec_enum ("status",
 
281
    "status", "Status of the dispatch operation",
 
282
    EMPATHY_TYPE_DISPATCH_OPERATION_STATE, 0,
 
283
    G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 
284
  g_object_class_install_property (object_class, PROP_STATUS, param_spec);
 
285
}
 
286
 
 
287
void
 
288
empathy_dispatch_operation_dispose (GObject *object)
 
289
{
 
290
  EmpathyDispatchOperation *self = EMPATHY_DISPATCH_OPERATION (object);
 
291
  EmpathyDispatchOperationPriv *priv =
 
292
    GET_PRIV (self);
 
293
 
 
294
  if (priv->dispose_has_run)
 
295
    return;
 
296
 
 
297
  priv->dispose_has_run = TRUE;
 
298
 
 
299
  g_object_unref (priv->connection);
 
300
 
 
301
  if (priv->channel_wrapper != NULL)
 
302
    g_object_unref (priv->channel_wrapper);
 
303
 
 
304
  if (priv->ready_handler != 0)
 
305
    g_signal_handler_disconnect (priv->channel_wrapper,
 
306
      priv->invalidated_handler);
 
307
 
 
308
 
 
309
  g_signal_handler_disconnect (priv->channel, priv->invalidated_handler);
 
310
  g_object_unref (priv->channel);
 
311
 
 
312
 
 
313
  if (priv->contact != NULL)
 
314
    g_object_unref (priv->contact);
 
315
 
 
316
  if (G_OBJECT_CLASS (empathy_dispatch_operation_parent_class)->dispose)
 
317
    G_OBJECT_CLASS (empathy_dispatch_operation_parent_class)->dispose (object);
 
318
}
 
319
 
 
320
void
 
321
empathy_dispatch_operation_finalize (GObject *object)
 
322
{
 
323
  /* free any data held directly by the object here */
 
324
  G_OBJECT_CLASS (empathy_dispatch_operation_parent_class)->finalize (object);
 
325
}
 
326
 
 
327
static void
 
328
empathy_dispatch_operation_set_status (EmpathyDispatchOperation *self,
 
329
  EmpathyDispatchOperationState status)
 
330
{
 
331
  EmpathyDispatchOperationPriv *priv = GET_PRIV (self);
 
332
 
 
333
  g_assert (status >= priv->status);
 
334
 
 
335
 
 
336
  if (priv->status != status)
 
337
    {
 
338
      DEBUG ("Dispatch operation %s status: %d -> %d",
 
339
        empathy_dispatch_operation_get_object_path (self),
 
340
        priv->status, status);
 
341
 
 
342
      priv->status = status;
 
343
      g_object_notify (G_OBJECT (self), "status");
 
344
 
 
345
      if (status == EMPATHY_DISPATCHER_OPERATION_STATE_PENDING)
 
346
        g_signal_emit (self, signals[READY], 0);
 
347
    }
 
348
}
 
349
 
 
350
static void
 
351
empathy_dispatcher_operation_tp_chat_ready_cb (GObject *object,
 
352
  GParamSpec *spec, gpointer user_data)
 
353
{
 
354
  EmpathyDispatchOperation *self = EMPATHY_DISPATCH_OPERATION (user_data);
 
355
  EmpathyDispatchOperationPriv *priv = GET_PRIV (self);
 
356
 
 
357
  if (!empathy_tp_chat_is_ready (EMPATHY_TP_CHAT (priv->channel_wrapper)))
 
358
    return;
 
359
 
 
360
  g_signal_handler_disconnect (priv->channel_wrapper, priv->ready_handler);
 
361
  priv->ready_handler = 0;
 
362
 
 
363
  empathy_dispatch_operation_set_status (self,
 
364
    EMPATHY_DISPATCHER_OPERATION_STATE_PENDING);
 
365
}
 
366
 
 
367
static void
 
368
empathy_dispatch_operation_channel_ready_cb (TpChannel *channel,
 
369
  const GError *error, gpointer user_data)
 
370
{
 
371
  EmpathyDispatchOperation *self = EMPATHY_DISPATCH_OPERATION (user_data);
 
372
  EmpathyDispatchOperationPriv *priv = GET_PRIV (self);
 
373
  GQuark channel_type;
 
374
 
 
375
  /* The error will be handled in empathy_dispatch_operation_invalidated */
 
376
  if (error != NULL)
 
377
    return;
 
378
 
 
379
  g_assert (channel == priv->channel);
 
380
 
 
381
  /* If the channel wrapper is defined, we assume it's ready */
 
382
  if (priv->channel_wrapper != NULL)
 
383
    goto ready;
 
384
 
 
385
  channel_type = tp_channel_get_channel_type_id (channel);
 
386
 
 
387
  if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_TEXT)
 
388
    {
 
389
      EmpathyTpChat *chat= empathy_tp_chat_new (channel);
 
390
      priv->channel_wrapper = G_OBJECT (chat);
 
391
 
 
392
      if (!empathy_tp_chat_is_ready (chat))
 
393
        {
 
394
          priv->ready_handler = g_signal_connect (chat, "notify::ready",
 
395
            G_CALLBACK (empathy_dispatcher_operation_tp_chat_ready_cb), self);
 
396
          return;
 
397
        }
 
398
 
 
399
    }
 
400
  else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA)
 
401
    {
 
402
       EmpathyTpCall *call = empathy_tp_call_new (channel);
 
403
       priv->channel_wrapper = G_OBJECT (call);
 
404
 
 
405
    }
 
406
  else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER)
 
407
    {
 
408
       EmpathyTpFile *file = empathy_tp_file_new (channel);
 
409
       priv->channel_wrapper = G_OBJECT (file);
 
410
    }
 
411
 
 
412
ready:
 
413
  empathy_dispatch_operation_set_status (self,
 
414
    EMPATHY_DISPATCHER_OPERATION_STATE_PENDING);
 
415
}
 
416
 
 
417
EmpathyDispatchOperation *
 
418
empathy_dispatch_operation_new (TpConnection *connection, TpChannel *channel,
 
419
  EmpathyContact *contact, gboolean incoming)
 
420
{
 
421
  return empathy_dispatch_operation_new_with_wrapper (connection, channel,
 
422
    contact, incoming, NULL);
 
423
}
 
424
 
 
425
EmpathyDispatchOperation *
 
426
empathy_dispatch_operation_new_with_wrapper (TpConnection *connection,
 
427
  TpChannel *channel, EmpathyContact *contact, gboolean incoming,
 
428
  GObject *wrapper)
 
429
{
 
430
  g_return_val_if_fail (connection != NULL, NULL);
 
431
  g_return_val_if_fail (channel != NULL, NULL);
 
432
 
 
433
  return EMPATHY_DISPATCH_OPERATION (
 
434
    g_object_new (EMPATHY_TYPE_DISPATCH_OPERATION,
 
435
      "connection", connection,
 
436
      "channel", channel,
 
437
      "channel-wrapper", wrapper,
 
438
      "contact", contact,
 
439
      "incoming", incoming,
 
440
      NULL));
 
441
}
 
442
 
 
443
void
 
444
empathy_dispatch_operation_start (EmpathyDispatchOperation *operation)
 
445
{
 
446
  EmpathyDispatchOperationPriv *priv;
 
447
 
 
448
  g_return_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation));
 
449
 
 
450
  priv = GET_PRIV (operation);
 
451
 
 
452
  g_return_if_fail (
 
453
    priv->status == EMPATHY_DISPATCHER_OPERATION_STATE_PENDING);
 
454
 
 
455
  if (priv->incoming && !priv->approved)
 
456
    empathy_dispatch_operation_set_status (operation,
 
457
      EMPATHY_DISPATCHER_OPERATION_STATE_APPROVING);
 
458
  else
 
459
    empathy_dispatch_operation_set_status (operation,
 
460
      EMPATHY_DISPATCHER_OPERATION_STATE_DISPATCHING);
 
461
}
 
462
 
 
463
void
 
464
empathy_dispatch_operation_approve (EmpathyDispatchOperation *operation)
 
465
{
 
466
  EmpathyDispatchOperationPriv *priv;
 
467
 
 
468
  g_return_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation));
 
469
 
 
470
  priv = GET_PRIV (operation);
 
471
 
 
472
  if (priv->status == EMPATHY_DISPATCHER_OPERATION_STATE_APPROVING)
 
473
    {
 
474
      DEBUG ("Approving operation %s",
 
475
        empathy_dispatch_operation_get_object_path (operation));
 
476
 
 
477
      empathy_dispatch_operation_set_status (operation,
 
478
        EMPATHY_DISPATCHER_OPERATION_STATE_DISPATCHING);
 
479
 
 
480
      g_signal_emit (operation, signals[APPROVED], 0);
 
481
    }
 
482
  else if (priv->status < EMPATHY_DISPATCHER_OPERATION_STATE_APPROVING)
 
483
    {
 
484
      DEBUG ("Pre-approving operation %s",
 
485
        empathy_dispatch_operation_get_object_path (operation));
 
486
      priv->approved = TRUE;
 
487
    }
 
488
  else
 
489
    {
 
490
      DEBUG (
 
491
        "Ignoring approval for %s as it's already past the approval stage",
 
492
        empathy_dispatch_operation_get_object_path (operation));
 
493
    }
 
494
}
 
495
 
 
496
/* Returns whether or not the operation was successfully claimed */
 
497
gboolean
 
498
empathy_dispatch_operation_claim (EmpathyDispatchOperation *operation)
 
499
{
 
500
  EmpathyDispatchOperationPriv *priv;
 
501
 
 
502
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation), FALSE);
 
503
 
 
504
  priv = GET_PRIV (operation);
 
505
 
 
506
  if (priv->status == EMPATHY_DISPATCHER_OPERATION_STATE_CLAIMED)
 
507
    return FALSE;
 
508
 
 
509
  empathy_dispatch_operation_set_status (operation,
 
510
    EMPATHY_DISPATCHER_OPERATION_STATE_CLAIMED);
 
511
 
 
512
  g_signal_emit (operation, signals[CLAIMED], 0);
 
513
 
 
514
  return TRUE;
 
515
}
 
516
 
 
517
TpConnection *
 
518
empathy_dispatch_operation_get_tp_connection (
 
519
  EmpathyDispatchOperation *operation)
 
520
{
 
521
  EmpathyDispatchOperationPriv *priv;
 
522
 
 
523
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation), NULL);
 
524
 
 
525
  priv = GET_PRIV (operation);
 
526
 
 
527
  return g_object_ref (priv->connection);
 
528
}
 
529
 
 
530
TpChannel *
 
531
empathy_dispatch_operation_get_channel (EmpathyDispatchOperation *operation)
 
532
{
 
533
  EmpathyDispatchOperationPriv *priv;
 
534
 
 
535
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation), NULL);
 
536
 
 
537
  priv = GET_PRIV (operation);
 
538
 
 
539
  return priv->channel;
 
540
}
 
541
 
 
542
GObject *
 
543
empathy_dispatch_operation_get_channel_wrapper (
 
544
  EmpathyDispatchOperation *operation)
 
545
{
 
546
  EmpathyDispatchOperationPriv *priv;
 
547
 
 
548
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation), NULL);
 
549
 
 
550
  priv = GET_PRIV (operation);
 
551
 
 
552
  return priv->channel_wrapper;
 
553
}
 
554
 
 
555
const gchar *
 
556
empathy_dispatch_operation_get_channel_type (
 
557
  EmpathyDispatchOperation *operation)
 
558
{
 
559
  EmpathyDispatchOperationPriv *priv;
 
560
 
 
561
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation), NULL);
 
562
 
 
563
  priv = GET_PRIV (operation);
 
564
 
 
565
  return tp_channel_get_channel_type (priv->channel);
 
566
}
 
567
 
 
568
GQuark
 
569
empathy_dispatch_operation_get_channel_type_id (
 
570
  EmpathyDispatchOperation *operation)
 
571
{
 
572
  EmpathyDispatchOperationPriv *priv;
 
573
 
 
574
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation), 0);
 
575
 
 
576
  priv = GET_PRIV (operation);
 
577
 
 
578
  return tp_channel_get_channel_type_id (priv->channel);
 
579
}
 
580
 
 
581
const gchar *
 
582
empathy_dispatch_operation_get_object_path (
 
583
  EmpathyDispatchOperation *operation)
 
584
{
 
585
  EmpathyDispatchOperationPriv *priv;
 
586
 
 
587
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation), NULL);
 
588
 
 
589
  priv = GET_PRIV (operation);
 
590
 
 
591
  return tp_proxy_get_object_path (TP_PROXY (priv->channel));
 
592
}
 
593
 
 
594
EmpathyDispatchOperationState
 
595
empathy_dispatch_operation_get_status (EmpathyDispatchOperation *operation)
 
596
{
 
597
  EmpathyDispatchOperationPriv *priv;
 
598
 
 
599
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation),
 
600
    EMPATHY_DISPATCHER_OPERATION_STATE_PREPARING);
 
601
 
 
602
  priv = GET_PRIV (operation);
 
603
 
 
604
  return priv->status;
 
605
}
 
606
 
 
607
gboolean
 
608
empathy_dispatch_operation_is_incoming (EmpathyDispatchOperation *operation)
 
609
{
 
610
  EmpathyDispatchOperationPriv *priv;
 
611
 
 
612
  g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation), FALSE);
 
613
 
 
614
  priv = GET_PRIV (operation);
 
615
 
 
616
  return priv->incoming;
 
617
}