Interface

Gio-2.0 ▶ Gio ▶ NetworkMonitor ▶ Interface

Interface for implementing NetworkMonitor. Contains only the virtual methods that need to be implemented.

interface Interface {
    vfunc_can_reach(
        connectable: Gio.SocketConnectable,
        cancellable?: Gio.Cancellable,
    ): boolean;
    vfunc_can_reach_async(
        connectable: Gio.SocketConnectable,
        cancellable?: Gio.Cancellable,
        callback?: AsyncReadyCallback<Gio.NetworkMonitor.Interface>,
    ): void;
    vfunc_can_reach_finish(result: Gio.AsyncResult): boolean;
    vfunc_init(cancellable?: Gio.Cancellable): boolean;
    vfunc_network_changed(network_available: boolean): void;
}

Hierarchy (View Summary)

Index

Methods

vfunc_can_reach vfunc_can_reach_async vfunc_can_reach_finish vfunc_network_changed

Methods - Inherited from Gio.Initable.Interface

vfunc_init

Methods

  • Attempts to determine whether or not the host pointed to by connectable can be reached, without actually trying to connect to it.

    This may return true even when Gio.NetworkMonitor.network_available is false, if, for example, monitor can determine that connectable refers to a host on a local network.

    If monitor believes that an attempt to connect to connectable will succeed, it will return true. Otherwise, it will return false and set error to an appropriate error (such as Gio.IOErrorEnum.HOST_UNREACHABLE).

    Note that although this does not attempt to connect to connectable, it may still block for a brief period of time (eg, trying to do multicast DNS on the local network), so if you do not want to block, you should use g_network_monitor_can_reach_async().

    Parameters

    Returns boolean

  • the virtual function pointer for the GNetworkMonitor::network-changed signal.

    Parameters

    • network_available: boolean

    Returns void

Methods - Inherited from Gio.Initable.Interface

  • Initializes the object implementing the interface.

    This method is intended for language bindings. If writing in C, g_initable_new() should typically be used instead.

    The object must be initialized before any real use after initial construction, either with this function or g_async_initable_init_async().

    Implementations may also support cancellation. If cancellable is not null, then initialization can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned. If cancellable is not null and the object doesn't support cancellable initialization the error Gio.IOErrorEnum.NOT_SUPPORTED will be returned.

    If the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. See the [description][iface@Gio.Initable#description] for more details.

    Callers should not assume that a class which implements Gio.Initable can be initialized multiple times, unless the class explicitly documents itself as supporting this. Generally, a class’ implementation of init() can assume (and assert) that it will only be called once. Previously, this documentation recommended all Gio.Initable implementations should be idempotent; that recommendation was relaxed in GLib 2.54.

    If a class explicitly supports being initialized multiple times, it is recommended that the method is idempotent: multiple calls with the same arguments should return the same results. Only the first call initializes the object; further calls return the result of the first call.

    One reason why a class might need to support idempotent initialization is if it is designed to be used via the singleton pattern, with a GObject.ObjectClass.constructor that sometimes returns an existing instance. In this pattern, a caller would expect to be able to call g_initable_init() on the result of g_object_new(), regardless of whether it is in fact a new instance.

    Parameters

    Returns boolean