Gio.AsyncInitable.init_async

### Method

# Gio AsyncInitableinit_async

since: 2.22

#### Declaration [src]

    void
    g_async_initable_init_async (
      GAsyncInitable* initable,
      int io_priority,
      GCancellable* cancellable,
      GAsyncReadyCallback callback,
      gpointer user_data
    )

#### Description [src]

Starts asynchronous initialization of the object implementing the interface. This must be done before any real use of the object after initial construction. If the object also implements `GInitable` you can optionally call `g_initable_init()` instead.

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

When the initialization is finished, `callback` will be called. You can then call `g_async_initable_init_finish()` to get the result of the initialization.

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 `G_IO_ERROR_CANCELLED` will be returned. If `cancellable` is not `NULL`, and the object doesn’t support cancellable initialization, the error `G_IO_ERROR_NOT_SUPPORTED` will be returned.

As with `GInitable`, 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. They will often fail with `g_critical()` or g_warning(), but this must not be relied on.

Callers should not assume that a class which implements `GAsyncInitable` can be initialized multiple times; for more information, see g_initable_init(). If a class explicitly supports being initialized multiple times, implementation requires yielding all subsequent calls to `init_async()` on the results of the first call.

For classes that also support the `GInitable` interface, the default implementation of this method will run the `g_initable_init()` function in a thread, so if you want to support asynchronous initialization via threads, just implement the `GAsyncInitable` interface without overriding any interface methods.

Available since: 2.22

This method completes asynchronously. Use `g_async_initable_init_finish()` inside the `GAsyncReadyCallback` to obtain the result of the operation.

#### Parameters

`io_priority`

  Type: `int`

  The I/O priority of the operation.

`cancellable`

  Type: `GCancellable`

  Optional `GCancellable` object, `NULL` to ignore.

  The argument can be `NULL`.
  The data is owned by the caller of the method.

`callback`

  Type: `GAsyncReadyCallback`

  A `GAsyncReadyCallback` to call when the request is satisfied.

  The argument can be `NULL`.

`user_data`

  Type: `gpointer`

  The data to pass to callback function.

  The argument can be `NULL`.
  The data is owned by the caller of the method.