-
Notifications
You must be signed in to change notification settings - Fork 71
/
DBusProxy.d
705 lines (647 loc) · 27.1 KB
/
DBusProxy.d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
/*
* This file is part of gtkD.
*
* gtkD is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version, with
* some exceptions, please read the COPYING file.
*
* gtkD is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with gtkD; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
*/
// generated automatically - do not change
// find conversion definition on APILookup.txt
// implement new conversion functionalities on the wrap.utils pakage
/*
* Conversion parameters:
* inFile = GDBusProxy.html
* outPack = gio
* outFile = DBusProxy
* strct = GDBusProxy
* realStrct=
* ctorStrct=
* clss = DBusProxy
* interf =
* class Code: Yes
* interface Code: No
* template for:
* extend = GObject
* implements:
* prefixes:
* - g_dbus_proxy_
* omit structs:
* omit prefixes:
* omit code:
* - g_dbus_proxy_new_finish
* - g_dbus_proxy_new_for_bus_finish
* omit signals:
* imports:
* - glib.Str
* - glib.ErrorG
* - glib.GException
* - glib.Variant
* - gio.AsyncResultIF
* - gio.Cancellable
* - gio.DBusConnection
* structWrap:
* - GAsyncResult* -> AsyncResultIF
* - GCancellable* -> Cancellable
* - GDBusConnection* -> DBusConnection
* - GVariant* -> Variant
* module aliases:
* local aliases:
* overrides:
*/
module gio.DBusProxy;
public import gtkc.giotypes;
private import gtkc.gio;
private import glib.ConstructionException;
private import gobject.Signals;
public import gtkc.gdktypes;
private import glib.Str;
private import glib.ErrorG;
private import glib.GException;
private import glib.Variant;
private import gio.AsyncResultIF;
private import gio.Cancellable;
private import gio.DBusConnection;
private import gobject.ObjectG;
/**
* Description
* GDBusProxy is a base class used for proxies to access a D-Bus
* interface on a remote object. A GDBusProxy can be constructed for
* both well-known and unique names.
* By default, GDBusProxy will cache all properties (and listen to
* changes) of the remote object, and proxy all signals that gets
* emitted. This behaviour can be changed by passing suitable
* GDBusProxyFlags when the proxy is created. If the proxy is for a
* well-known name, the property cache is flushed when the name owner
* vanishes and reloaded when a name owner appears.
* If a GDBusProxy is used for a well-known name, the owner of the
* name is tracked and can be read from
* "g-name-owner". Connect to the "notify" signal to
* get notified of changes. Additionally, only signals and property
* changes emitted from the current name owner are considered and
* calls are always sent to the current name owner. This avoids a
* number of race conditions when the name is lost by one owner and
* claimed by another. However, if no name owner currently exists,
* then calls will be sent to the well-known name which may result in
* the message bus launching an owner (unless
* G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is set).
* The generic "g-properties-changed" and "g-signal"
* signals are not very convenient to work with. Therefore, the recommended
* way of working with proxies is to subclass GDBusProxy, and have
* more natural properties and signals in your derived class.
* See Example 19, “GDBusProxy subclass example” for an example.
* $(DDOC_COMMENT example)
*/
public class DBusProxy : ObjectG
{
/** the main Gtk struct */
protected GDBusProxy* gDBusProxy;
public GDBusProxy* getDBusProxyStruct()
{
return gDBusProxy;
}
/** the main Gtk struct as a void* */
protected override void* getStruct()
{
return cast(void*)gDBusProxy;
}
/**
* Sets our main struct and passes it to the parent class
*/
public this (GDBusProxy* gDBusProxy)
{
if(gDBusProxy is null)
{
this = null;
return;
}
//Check if there already is a D object for this gtk struct
void* ptr = getDObject(cast(GObject*)gDBusProxy);
if( ptr !is null )
{
this = cast(DBusProxy)ptr;
return;
}
super(cast(GObject*)gDBusProxy);
this.gDBusProxy = gDBusProxy;
}
protected override void setStruct(GObject* obj)
{
super.setStruct(obj);
gDBusProxy = cast(GDBusProxy*)obj;
}
/**
* Finishes creating a GDBusProxy.
* Since 2.26
* Params:
* res = A GAsyncResult obtained from the GAsyncReadyCallback
* function passed to g_dbus_proxy_new().
* forBus = If true finish an address.
* Throws: GException on failure.
* Throws: ConstructionException GTK+ fails to create the object.
*/
public this (AsyncResultIF res, bool forBus = false)
{
// GDBusProxy * g_dbus_proxy_new_finish (GAsyncResult *res, GError **error);
GError* err = null;
GDBusProxy* p;
if ( forBus )
{
p = g_dbus_proxy_new_for_bus_finish((res is null) ? null : res.getAsyncResultTStruct(), &err);
}
else
{
p = g_dbus_proxy_new_finish((res is null) ? null : res.getAsyncResultTStruct(), &err);
}
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
if(p is null)
{
throw new ConstructionException("null returned by g_dbus_proxy_new_finish((res is null) ? null : res.getAsyncResultTStruct(), &err)");
}
this(cast(GDBusProxy*) p);
}
/**
*/
int[string] connectedSignals;
void delegate(Variant, GStrv, DBusProxy)[] onGPropertiesChangedListeners;
/**
* Emitted when one or more D-Bus properties on proxy changes. The
* local cache has already been updated when this signal fires. Note
* that both changed_properties and invalidated_properties are
* guaranteed to never be NULL (either may be empty though).
* This signal corresponds to the
* PropertiesChanged D-Bus signal on the
* org.freedesktop.DBus.Properties interface.
* Since 2.26
*/
void addOnGPropertiesChanged(void delegate(Variant, GStrv, DBusProxy) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
{
if ( !("g-properties-changed" in connectedSignals) )
{
Signals.connectData(
getStruct(),
"g-properties-changed",
cast(GCallback)&callBackGPropertiesChanged,
cast(void*)this,
null,
connectFlags);
connectedSignals["g-properties-changed"] = 1;
}
onGPropertiesChangedListeners ~= dlg;
}
extern(C) static void callBackGPropertiesChanged(GDBusProxy* proxyStruct, GVariant* changedProperties, GStrv invalidatedProperties, DBusProxy dBusProxy)
{
foreach ( void delegate(Variant, GStrv, DBusProxy) dlg ; dBusProxy.onGPropertiesChangedListeners )
{
dlg(new Variant(changedProperties), invalidatedProperties, dBusProxy);
}
}
void delegate(string, string, Variant, DBusProxy)[] onGSignalListeners;
/**
* Emitted when a signal from the remote object and interface that proxy is for, has been received.
* Since 2.26
*/
void addOnGSignal(void delegate(string, string, Variant, DBusProxy) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
{
if ( !("g-signal" in connectedSignals) )
{
Signals.connectData(
getStruct(),
"g-signal",
cast(GCallback)&callBackGSignal,
cast(void*)this,
null,
connectFlags);
connectedSignals["g-signal"] = 1;
}
onGSignalListeners ~= dlg;
}
extern(C) static void callBackGSignal(GDBusProxy* proxyStruct, gchar* senderName, gchar* signalName, GVariant* parameters, DBusProxy dBusProxy)
{
foreach ( void delegate(string, string, Variant, DBusProxy) dlg ; dBusProxy.onGSignalListeners )
{
dlg(Str.toString(senderName), Str.toString(signalName), new Variant(parameters), dBusProxy);
}
}
/**
* Creates a proxy for accessing interface_name on the remote object
* at object_path owned by name at connection and asynchronously
* loads D-Bus properties unless the
* G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to
* the "g-properties-changed" signal to get notified about
* property changes.
* If the G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
* match rules for signals. Connect to the "g-signal" signal
* to handle signals from the remote object.
* If name is a well-known name and the
* G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START flag isn't set and no name
* owner currently exists, the message bus will be requested to launch
* a name owner for the name.
* This is a failable asynchronous constructor - when the proxy is
* ready, callback will be invoked and you can use
* g_dbus_proxy_new_finish() to get the result.
* See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
* See Example 10, “GDBusProxy for a well-known-name” for an example of how GDBusProxy can be used.
* Since 2.26
* Params:
* connection = A GDBusConnection.
* flags = Flags used when constructing the proxy.
* info = A GDBusInterfaceInfo specifying the minimal interface that proxy conforms to or NULL. [allow-none]
* name = A bus name (well-known or unique) or NULL if connection is not a message bus connection. [allow-none]
* objectPath = An object path.
* interfaceName = A D-Bus interface name.
* cancellable = A GCancellable or NULL.
* callback = Callback function to invoke when the proxy is ready.
* userData = User data to pass to callback.
*/
public static void newDBusProxy(DBusConnection connection, GDBusProxyFlags flags, GDBusInterfaceInfo* info, string name, string objectPath, string interfaceName, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
{
// void g_dbus_proxy_new (GDBusConnection *connection, GDBusProxyFlags flags, GDBusInterfaceInfo *info, const gchar *name, const gchar *object_path, const gchar *interface_name, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
g_dbus_proxy_new((connection is null) ? null : connection.getDBusConnectionStruct(), flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
}
/**
* Creates a proxy for accessing interface_name on the remote object
* at object_path owned by name at connection and synchronously
* loads D-Bus properties unless the
* G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used.
* If the G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
* match rules for signals. Connect to the "g-signal" signal
* to handle signals from the remote object.
* If name is a well-known name and the
* G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START flag isn't set and no name
* owner currently exists, the message bus will be requested to launch
* a name owner for the name.
* This is a synchronous failable constructor. See g_dbus_proxy_new()
* and g_dbus_proxy_new_finish() for the asynchronous version.
* See Example 10, “GDBusProxy for a well-known-name” for an example of how GDBusProxy can be used.
* Since 2.26
* Params:
* connection = A GDBusConnection.
* flags = Flags used when constructing the proxy.
* info = A GDBusInterfaceInfo specifying the minimal interface that proxy conforms to or NULL. [allow-none]
* name = A bus name (well-known or unique) or NULL if connection is not a message bus connection. [allow-none]
* objectPath = An object path.
* interfaceName = A D-Bus interface name.
* cancellable = A GCancellable or NULL. [allow-none]
* Throws: GException on failure.
* Throws: ConstructionException GTK+ fails to create the object.
*/
public this (DBusConnection connection, GDBusProxyFlags flags, GDBusInterfaceInfo* info, string name, string objectPath, string interfaceName, Cancellable cancellable)
{
// GDBusProxy * g_dbus_proxy_new_sync (GDBusConnection *connection, GDBusProxyFlags flags, GDBusInterfaceInfo *info, const gchar *name, const gchar *object_path, const gchar *interface_name, GCancellable *cancellable, GError **error);
GError* err = null;
auto p = g_dbus_proxy_new_sync((connection is null) ? null : connection.getDBusConnectionStruct(), flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
if(p is null)
{
throw new ConstructionException("null returned by g_dbus_proxy_new_sync((connection is null) ? null : connection.getDBusConnectionStruct(), flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err)");
}
this(cast(GDBusProxy*) p);
}
/**
* Like g_dbus_proxy_new() but takes a GBusType instead of a GDBusConnection.
* See Example 10, “GDBusProxy for a well-known-name” for an example of how GDBusProxy can be used.
* Since 2.26
* Params:
* busType = A GBusType.
* flags = Flags used when constructing the proxy.
* info = A GDBusInterfaceInfo specifying the minimal interface that proxy conforms to or NULL. [allow-none]
* name = A bus name (well-known or unique).
* objectPath = An object path.
* interfaceName = A D-Bus interface name.
* cancellable = A GCancellable or NULL.
* callback = Callback function to invoke when the proxy is ready.
* userData = User data to pass to callback.
*/
public static void newForBus(GBusType busType, GDBusProxyFlags flags, GDBusInterfaceInfo* info, string name, string objectPath, string interfaceName, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
{
// void g_dbus_proxy_new_for_bus (GBusType bus_type, GDBusProxyFlags flags, GDBusInterfaceInfo *info, const gchar *name, const gchar *object_path, const gchar *interface_name, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
g_dbus_proxy_new_for_bus(busType, flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
}
/**
* Like g_dbus_proxy_new_sync() but takes a GBusType instead of a GDBusConnection.
* See Example 10, “GDBusProxy for a well-known-name” for an example of how GDBusProxy can be used.
* Since 2.26
* Params:
* busType = A GBusType.
* flags = Flags used when constructing the proxy.
* info = A GDBusInterfaceInfo specifying the minimal interface
* that proxy conforms to or NULL. [allow-none]
* name = A bus name (well-known or unique).
* objectPath = An object path.
* interfaceName = A D-Bus interface name.
* cancellable = A GCancellable or NULL.
* Throws: GException on failure.
* Throws: ConstructionException GTK+ fails to create the object.
*/
public this (GBusType busType, GDBusProxyFlags flags, GDBusInterfaceInfo* info, string name, string objectPath, string interfaceName, Cancellable cancellable)
{
// GDBusProxy * g_dbus_proxy_new_for_bus_sync (GBusType bus_type, GDBusProxyFlags flags, GDBusInterfaceInfo *info, const gchar *name, const gchar *object_path, const gchar *interface_name, GCancellable *cancellable, GError **error);
GError* err = null;
auto p = g_dbus_proxy_new_for_bus_sync(busType, flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
if(p is null)
{
throw new ConstructionException("null returned by g_dbus_proxy_new_for_bus_sync(busType, flags, info, Str.toStringz(name), Str.toStringz(objectPath), Str.toStringz(interfaceName), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err)");
}
this(cast(GDBusProxy*) p);
}
/**
* Gets the flags that proxy was constructed with.
* Since 2.26
* Returns: Flags from the GDBusProxyFlags enumeration.
*/
public GDBusProxyFlags getFlags()
{
// GDBusProxyFlags g_dbus_proxy_get_flags (GDBusProxy *proxy);
return g_dbus_proxy_get_flags(gDBusProxy);
}
/**
* Gets the connection proxy is for.
* Since 2.26
* Returns: A GDBusConnection owned by proxy. Do not free. [transfer none]
*/
public DBusConnection getConnection()
{
// GDBusConnection * g_dbus_proxy_get_connection (GDBusProxy *proxy);
auto p = g_dbus_proxy_get_connection(gDBusProxy);
if(p is null)
{
return null;
}
return new DBusConnection(cast(GDBusConnection*) p);
}
/**
* Gets the name that proxy was constructed for.
* Since 2.26
* Returns: A string owned by proxy. Do not free.
*/
public string getName()
{
// const gchar * g_dbus_proxy_get_name (GDBusProxy *proxy);
return Str.toString(g_dbus_proxy_get_name(gDBusProxy));
}
/**
* The unique name that owns the name that proxy is for or NULL if
* no-one currently owns that name. You may connect to the
* "notify" signal to track changes to the
* "g-name-owner" property.
* Since 2.26
* Returns: The name owner or NULL if no name owner exists. Free with g_free().
*/
public string getNameOwner()
{
// gchar * g_dbus_proxy_get_name_owner (GDBusProxy *proxy);
return Str.toString(g_dbus_proxy_get_name_owner(gDBusProxy));
}
/**
* Gets the object path proxy is for.
* Since 2.26
* Returns: A string owned by proxy. Do not free.
*/
public string getObjectPath()
{
// const gchar * g_dbus_proxy_get_object_path (GDBusProxy *proxy);
return Str.toString(g_dbus_proxy_get_object_path(gDBusProxy));
}
/**
* Gets the D-Bus interface name proxy is for.
* Since 2.26
* Returns: A string owned by proxy. Do not free.
*/
public string getInterfaceName()
{
// const gchar * g_dbus_proxy_get_interface_name (GDBusProxy *proxy);
return Str.toString(g_dbus_proxy_get_interface_name(gDBusProxy));
}
/**
* Gets the timeout to use if -1 (specifying default timeout) is
* passed as timeout_msec in the g_dbus_proxy_call() and
* g_dbus_proxy_call_sync() functions.
* See the "g-default-timeout" property for more details.
* Since 2.26
* Returns: Timeout to use for proxy.
*/
public int getDefaultTimeout()
{
// gint g_dbus_proxy_get_default_timeout (GDBusProxy *proxy);
return g_dbus_proxy_get_default_timeout(gDBusProxy);
}
/**
* Sets the timeout to use if -1 (specifying default timeout) is
* passed as timeout_msec in the g_dbus_proxy_call() and
* g_dbus_proxy_call_sync() functions.
* See the "g-default-timeout" property for more details.
* Since 2.26
* Params:
* timeoutMsec = Timeout in milliseconds.
*/
public void setDefaultTimeout(int timeoutMsec)
{
// void g_dbus_proxy_set_default_timeout (GDBusProxy *proxy, gint timeout_msec);
g_dbus_proxy_set_default_timeout(gDBusProxy, timeoutMsec);
}
/**
* Looks up the value for a property from the cache. This call does no
* blocking IO.
* If proxy has an expected interface (see
* "g-interface-info"), then property_name (for existence)
* is checked against it.
* Since 2.26
* Params:
* propertyName = Property name.
* Returns: A reference to the GVariant instance that holds the value for property_name or NULL if the value is not in the cache. The returned reference must be freed with g_variant_unref().
*/
public Variant getCachedProperty(string propertyName)
{
// GVariant * g_dbus_proxy_get_cached_property (GDBusProxy *proxy, const gchar *property_name);
auto p = g_dbus_proxy_get_cached_property(gDBusProxy, Str.toStringz(propertyName));
if(p is null)
{
return null;
}
return new Variant(cast(GVariant*) p);
}
/**
* If value is not NULL, sets the cached value for the property with
* name property_name to the value in value.
* If value is NULL, then the cached value is removed from the
* property cache.
* If proxy has an expected interface (see
* "g-interface-info"), then property_name (for existence)
* and value (for the type) is checked against it.
* If the value GVariant is floating, it is consumed. This allows
* convenient 'inline' use of g_variant_new(), e.g.
* $(DDOC_COMMENT example)
* Normally you will not need to use this method since proxy is
* tracking changes using the
* org.freedesktop.DBus.Properties.PropertiesChanged
* D-Bus signal. However, for performance reasons an object may decide
* to not use this signal for some properties and instead use a
* proprietary out-of-band mechanism to transmit changes.
* As a concrete example, consider an object with a property
* ChatroomParticipants which is an array of
* strings. Instead of transmitting the same (long) array every time
* the property changes, it is more efficient to only transmit the
* delta using e.g. signals ChatroomParticipantJoined(String
* name) and ChatroomParticipantParted(String
* name).
* Since 2.26
* Params:
* propertyName = Property name.
* value = Value for the property or NULL to remove it from the cache. [allow-none]
*/
public void setCachedProperty(string propertyName, Variant value)
{
// void g_dbus_proxy_set_cached_property (GDBusProxy *proxy, const gchar *property_name, GVariant *value);
g_dbus_proxy_set_cached_property(gDBusProxy, Str.toStringz(propertyName), (value is null) ? null : value.getVariantStruct());
}
/**
* Gets the names of all cached properties on proxy.
* Since 2.26
* Returns: A NULL-terminated array of strings or NULL if proxy has no cached properties. Free the returned array with g_strfreev().
*/
public string[] getCachedPropertyNames()
{
// gchar ** g_dbus_proxy_get_cached_property_names (GDBusProxy *proxy);
return Str.toStringArray(g_dbus_proxy_get_cached_property_names(gDBusProxy));
}
/**
* Ensure that interactions with proxy conform to the given
* interface. For example, when completing a method call, if the type
* signature of the message isn't what's expected, the given GError
* is set. Signals that have a type signature mismatch are simply
* dropped.
* See the "g-interface-info" property for more details.
* Since 2.26
* Params:
* info = Minimum interface this proxy conforms to or NULL to unset. [allow-none]
*/
public void setInterfaceInfo(GDBusInterfaceInfo* info)
{
// void g_dbus_proxy_set_interface_info (GDBusProxy *proxy, GDBusInterfaceInfo *info);
g_dbus_proxy_set_interface_info(gDBusProxy, info);
}
/**
* Returns the GDBusInterfaceInfo, if any, specifying the minimal
* interface that proxy conforms to.
* See the "g-interface-info" property for more details.
* Since 2.26
* Returns: A GDBusInterfaceInfo or NULL. Do not unref the returned object, it is owned by proxy.
*/
public GDBusInterfaceInfo* getInterfaceInfo()
{
// GDBusInterfaceInfo * g_dbus_proxy_get_interface_info (GDBusProxy *proxy);
return g_dbus_proxy_get_interface_info(gDBusProxy);
}
/**
* Asynchronously invokes the method_name method on proxy.
* If method_name contains any dots, then name is split into interface and
* method name parts. This allows using proxy for invoking methods on
* other interfaces.
* If the GDBusConnection associated with proxy is closed then
* the operation will fail with G_IO_ERROR_CLOSED. If
* cancellable is canceled, the operation will fail with
* G_IO_ERROR_CANCELLED. If parameters contains a value not
* compatible with the D-Bus protocol, the operation fails with
* G_IO_ERROR_INVALID_ARGUMENT.
* If the parameters GVariant is floating, it is consumed. This allows
* Since 2.26
* Params:
* methodName = Name of method to invoke.
* parameters = A GVariant tuple with parameters for the signal or NULL if not passing parameters. [allow-none]
* flags = Flags from the GDBusCallFlags enumeration.
* timeoutMsec = The timeout in milliseconds (with G_MAXINT meaning
* "infinite") or -1 to use the proxy default timeout.
* cancellable = A GCancellable or NULL.
* callback = A GAsyncReadyCallback to call when the request is satisfied or NULL if you don't
* care about the result of the method invocation.
* userData = The data to pass to callback.
*/
public void call(string methodName, Variant parameters, GDBusCallFlags flags, int timeoutMsec, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
{
// void g_dbus_proxy_call (GDBusProxy *proxy, const gchar *method_name, GVariant *parameters, GDBusCallFlags flags, gint timeout_msec, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
g_dbus_proxy_call(gDBusProxy, Str.toStringz(methodName), (parameters is null) ? null : parameters.getVariantStruct(), flags, timeoutMsec, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
}
/**
* Finishes an operation started with g_dbus_proxy_call().
* Since 2.26
* Params:
* res = A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_proxy_call().
* Returns: NULL if error is set. Otherwise a GVariant tuple with return values. Free with g_variant_unref().
* Throws: GException on failure.
*/
public Variant callFinish(AsyncResultIF res)
{
// GVariant * g_dbus_proxy_call_finish (GDBusProxy *proxy, GAsyncResult *res, GError **error);
GError* err = null;
auto p = g_dbus_proxy_call_finish(gDBusProxy, (res is null) ? null : res.getAsyncResultTStruct(), &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
if(p is null)
{
return null;
}
return new Variant(cast(GVariant*) p);
}
/**
* Synchronously invokes the method_name method on proxy.
* If method_name contains any dots, then name is split into interface and
* method name parts. This allows using proxy for invoking methods on
* other interfaces.
* If the GDBusConnection associated with proxy is disconnected then
* the operation will fail with G_IO_ERROR_CLOSED. If
* cancellable is canceled, the operation will fail with
* G_IO_ERROR_CANCELLED. If parameters contains a value not
* compatible with the D-Bus protocol, the operation fails with
* G_IO_ERROR_INVALID_ARGUMENT.
* If the parameters GVariant is floating, it is consumed. This allows
* Since 2.26
* Params:
* methodName = Name of method to invoke.
* parameters = A GVariant tuple with parameters for the signal
* or NULL if not passing parameters. [allow-none]
* flags = Flags from the GDBusCallFlags enumeration.
* timeoutMsec = The timeout in milliseconds (with G_MAXINT meaning
* "infinite") or -1 to use the proxy default timeout.
* cancellable = A GCancellable or NULL.
* Returns: NULL if error is set. Otherwise a GVariant tuple with return values. Free with g_variant_unref().
* Throws: GException on failure.
*/
public Variant callSync(string methodName, Variant parameters, GDBusCallFlags flags, int timeoutMsec, Cancellable cancellable)
{
// GVariant * g_dbus_proxy_call_sync (GDBusProxy *proxy, const gchar *method_name, GVariant *parameters, GDBusCallFlags flags, gint timeout_msec, GCancellable *cancellable, GError **error);
GError* err = null;
auto p = g_dbus_proxy_call_sync(gDBusProxy, Str.toStringz(methodName), (parameters is null) ? null : parameters.getVariantStruct(), flags, timeoutMsec, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
if (err !is null)
{
throw new GException( new ErrorG(err) );
}
if(p is null)
{
return null;
}
return new Variant(cast(GVariant*) p);
}
}