Philip Withnall
philip.withnall@collabora.co.uk 2015
Jak použít asynchronní metody ve stylu GLib v různých situacích

# Asynchronní programování

#

        Shrnutí

          Dávejte přednost asynchronním voláním před synchronním voláním, nebo výslovným použitím vláken ()
          Naučte se a dodržujte vzory GLib pro deklarování asynchronních API ()
          Zpětná volání z asynchronních funkcí umístěte v souboru v pořadí jejich provádění, aby byl snadný přehled toku provádění kódu ()
          Používejte přítomnosti GTask nebo GCancellable k indikaci, jestli operace probíhá (, )
          Když spouštíte paralelní operace, sledujte kolik jich bylo spuštěno a kolik bylo dokončeno. Po dokončení celé operace by rozdíl obou hodnot měl být nula ()
          Oddělte stavy pro operace do struktury „data úlohy“ pro objekty GTask, aby se operace daly snáze znovu použít bez potřeby změn v globální obsluze stavu ()
          Popřemýšlejte, jak asynchronní metody v instanci objektu souvisí s finalizací instance ()

# Koncepty

GLib podporuje asynchronní programování, kdy dlouhotrvající operace mohou být spuštěny, běžet „na pozadí“ a vyvolat zpětné volání, když jsou dokončeny a jejich výsledky jsou k dispozici. Což je v přímém kontrastu se synchronními dlouhotrvajícími operacemi, které jsou samostatnými voláními funkcí blokujícími až do svého dokončení řízení toku programu.

Jak je vysvětleno v kapitolách a , asynchronní operace by měly být upřednostňovány před synchronními, i před cíleným použitím vláken. Na rozdíl od synchronních neblokují hlavní kontext a jejich správné použití je snazší než u vláken. Navíc často mají nižší dopad na výkon, než spouštění vláken.

# Vzory API

Asynchronní volání se řídí standardními vzory v kódu GLib. Pro operaci nazvanou `load_data` na třídě `File` ve jmenném prostoru `Foo` to bude:

foo_file_load_data_async (FooFile *self, …, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
foo_file_load_data_finish (FooFile *self, GAsyncResult *result, …, GError **error)

Parametry `…` z `foo_file_load_data_async()` jsou specifické pro operaci. V tomto případě je o velikost vyrovnávací paměti, do které se načítá. Obdobně u `foo_file_load_data_finish()` jsou specifické pro operaci návratové hodnoty, v tomto případě se jako typ řetězec vrací umístění.

Když je zavolána funkce `foo_file_load_data_async()`, naplánuje operaci načtení na pozadí (jako nový popisovač souboru v `GMainContext`, nebo jako pracovní vlákno), a bez blokování se vrátí.

Když je operace dokončena, je provedeno `zpětné volání` ve stejném `GMainContext`, jako původní asynchronní volání. Zpětné volání je zavoláno právě jednou, nezávisle na tom, jestli operace dopadla dobře, nebo selhala.

Ze zpětného volání může být uživatelským kódem zavolána funkce `foo_file_load_data_finish()` kvůli získání návratové hodnoty a podrobností o chybě, přičemž se jí předává instance `GAsyncResult`, která byla předána zpětnému volání.

# Životní průběh operace

Když se píše asynchronní operace, je běžné ji napsat jako metodu třídy. V tomto případě je důležité definovat, jak běžící operace nad instancí třídy komunikují s finalizací instance. Existují dva přístupy:

## Silný

Běžící operace zachovává odkaz na instanci třídy a nutí ji zůstat naživu po dobu operace. Třída může poskytovat nějaký druh metody „close“ nebo „cancel“, které mohou být použity jinou třídou k vynucení zrušení operace a umožnit této instanci finalizaci.

## Slabý

Běžící operace nezachovává odkaz na instanci třídy a třída ruší operaci (pomocí `g_cancellable_cancel()`) ve své uvolňovací funkci.

To, který přístup je použit, závisí na návrhu třídy. Třída, která obaluje konkrétní operaci (třída `MyFileTransfer` například), může chtít používat slabý přístup. Třída, která spravuje více síťových připojení a asynchronních operací nad nimi, může naopak používat silný přístup. Například kvůli příchozím síťovým připojením nemusí mít úplné řízení nad plánováním svých asynchronních volání, takže slabý přístup by nebyl vhodný – kód zahazující odkaz na objekt by si nemohl být jistý, jestli nešťastnou náhodou nezabije nové síťové připojení.

# Příklad použití asynchronních funkcí

Častým případem je, že je k dokončení operace zapotřebí více asynchronních volání. Například, otevření souboru pro čtení, následně provedení několika čtení a pak zavření souboru. Nebo otevření několika síťových soketů souběžně a čekání, dokud se všechny neotevřou, než se může pokračovat s další prací se sítí. Nějaké příklady těchto situací jsou uvedeny níže.

## Jedna samostatná operace

Jedna samostatná asynchronní operace vyžaduje dvě funkce: jednu pro spuštění operace a jednu pro její dokončení. V jazyce C žádanou částí provádění asynchronního volání je správně uchovaný stav mezi těmito dvěma funkcemi a obsluha změn tohoto stavu v čase mezi zavoláním těchto dvou funkcí. Například, zrušení probíhajícího asynchronního volání je změna stavu, a když není implementováno pečlivě, aktualizace uživatelského rozhraní (například) provedené při rušení operace budou vráceny do původního stavu aktualizací ve zpětném volání operace.

Tento příklad předvádí kopírování souboru z jednoho místa v souborovém systému na druhé. Předvedené klíčové principy jsou:

Umístění funkcí `copy_button_clicked_cb()` (spuštění) a `copy_finish_cb()` (dokončení) v postupném pořadí pomocí dopředné deklarace pro `copy_finish_cb()`. To znamená, že řízení toku pokračuje lineárně od začátku do konce souboru se zdrojovým kódem, místo aby se `copy_button_clicked_cb()` bralo z konce a pokračovalo se na `copy_button_clicked_cb()` někde jinde v souboru.

Používejte `GCancellable`, aby se operace po té, co je spuštěna, dala zrušit. Kód v `cancel_button_clicked_cb()` je velmi jednoduchý: jelikož je zaručeno vyvolání zpětného volání `copy_finish_cb()`, když je operace dokončena (i když je dokončena předčasně zrušením), všechny aktualizace uživatelského rozhraní a stavu pro zrušení mohou být obslouženy zde, místo aby se tak stalo v `cancel_button_clicked_cb()`.

Operace běží přesně po dobu, kdy `MyObjectPrivate.copy_cancellable` není `NULL`, díky čemuž je jednoduché sledovat běžící operace. Uvědomte si, že to znamená, že jen jedna kopírovací operace může být spuštěna přes `copy_button_clicked_cb()` v jeden okamžik. Tímto způsobem nejde jednoduše použít jednu `GCancellable` pro více operací.

static void copy_finish_cb (GObject *source_object, GAsyncResult *result, gpointer user_data);

static void copy_button_clicked_cb (GtkButton *button gpointer user_data) { MyObjectPrivate *priv; GFile *source = NULL, *destination = NULL; /* owned */

priv = my_object_get_instance_private (MY_OBJECT (user_data));

/* Operace již běží? */ if (priv->copy_cancellable != NULL) { g_debug ("Copy already in progress."); return; }

/* Sestaví cestu k zdrojovému a cílovému souboru */ source = g_file_new_for_path (/* nějaká cesta vygenerovaná z uživ. rozhraní */); destination = g_file_new_for_path (/* nějaká další cesta vygenerovaná z uživ. rozhraní */);

/* Nastaví jako zrušitelné */ priv->copy_cancellable = g_cancellable_new ();

g_file_copy_async (source, destination, G_FILE_COPY_NONE, G_PRIORITY_DEFAULT, priv->copy_cancellable, NULL, NULL, copy_finish_cb, user_data);

g_object_unref (destination); g_object_unref (source);

/* Aktualizuje uživ. rozhraní, aby ukazovalo průběh */ … }

static void copy_finish_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { MyObjectPrivate *priv; GFile *source; /* unowned */ GError *error = NULL;

source = G_FILE (source_object); priv = my_object_get_instance_private (MY_OBJECT (user_data));

/* Obsluha dokončení operace */ g_file_copy_finish (source, result, &error);

if (error != NULL && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { /* Mělo by aktualizovat uživatelské rozhraní, aby oznámilo selhání * Ignoruje selhání kvůli zrušení */ g_warning ("Failed to copy file: %s", error->message); }

g_clear_error (&error);

/* Smaže příznak zrušitelnosti, aby dalo najevo dokončení operace */ g_clear_object (&priv->copy_cancellable);

/* Aktualizace uživ. rozhraní, aby ukazovalo dokončení kopírování */ … }

static void cancel_button_clicked_cb (GtkButton *button, gpointer user_data) { MyObjectPrivate *priv; GFile *source = NULL, *destination = NULL; /* owned */

priv = my_object_get_instance_private (MY_OBJECT (user_data));

/* Operace probíhá? Žádná operace, když @copy_cancellable je %NULL. */ g_cancellable_cancel (priv->copy_cancellable); }

static void my_object_dispose (GObject *obj) { MyObjectPrivate *priv;

priv = my_object_get_instance_private (MY_OBJECT (obj));

/* Zrušení případné probíhající operace kopírování. * * Tím se zajistí, že když je #MyObject částečně uvolněn přes * kopírování, není zpětné volání vyvoláno s neplatným * ukazatelem na #MyObject. */\n" g_cancellable_cancel (priv->copy_cancellable);

/* Zde proveďte případná další uvolnění */ …

/* Zřetězení */ G_OBJECT_CLASS (my_object_parent_class)->dispose (obj); }

Pro srovnání, zde je ten stejný kód implementovaný pomocí synchronní verze `g_file_copy()`. Všimněte si, že pořadí příkazů je povětšinou stejné. Rušení v tomto případě nelez podporovat, protože uživatelské rozhraní je během kopírování blokované od příjmu události „click“ z tlačítka „Zrušit“, takže do parametru `GCancellable` předáváme `NULL`. To je také hlavní důvod, proč tento kód není v praxi použitelný.

static void copy_button_clicked_cb (GtkButton *button gpointer user_data) { MyObjectPrivate *priv; GFile *source = NULL, *destination = NULL; /* owned */

priv = my_object_get_instance_private (MY_OBJECT (user_data));

/* Sestaví cestu k zdrojovému a cílovému souboru */ source = g_file_new_for_path (/* nějaká cesta vygenerovaná z uživ. rozhraní */); destination = g_file_new_for_path (/* nějaká další cesta vygenerovaná z uživ. rozhraní */);

g_file_copy (source, destination, G_FILE_COPY_NONE, NULL /* cancellable */, NULL, NULL, &error);

g_object_unref (destination); g_object_unref (source);

/* Obsluha dokončení operace */ if (error != NULL) { /* Mělo by aktualizovat uživatelské rozhraní, aby oznámilo selhání * Ignoruje selhání kvůli zrušení */ g_warning ("Failed to copy file: %s", error->message); }

g_clear_error (&error);

/* Aktualizace uživ. rozhraní, aby ukazovalo dokončení kopírování */ … }

## Operace prováděné sériově

Běžnou situací je spuštění více asynchronních operací po sobě, když každá z operací závisí na dokončení předchozí.

V tomto příkladu aplikace čte adresu soketu ze souboru, otevře připojení na tuto adresu, přečte zprávu a pak skončí.

Klíčové body v tomto příkladu:

Jednotlivá zpětná volání jsou jednotně očíslovaná a ve správném pořadí umístěná v souboru se zdrojovým kódem, takže kód je provádět postupně ve stejném pořadí.

Stejně jako v kapitole , jediné `GCancellable` indikuje, že běží série operací. Její zrušení přeruší celou posloupnost.

Stejně jako v jsou čekající operace zrušeny, když je vlastnící instance `MyObject` uvolněna, aby se zabránilo pozdějšímu zavolání zpětného volání s neplatným ukazatelem `MyObject`.

poskytuje verzi tohoto příkladu obalenou pro pohodlí do `GTask`.

static void connect_to_server_cb1 (GObject *source_object, GAsyncResult *result, gpointer user_data); static void connect_to_server_cb2 (GObject *source_object, GAsyncResult *result, gpointer user_data); static void connect_to_server_cb3 (GObject *source_object, GAsyncResult *result, gpointer user_data);

static void connect_to_server (MyObject *self) { MyObjectPrivate *priv; GFile *address_file = NULL; /* owned */

priv = my_object_get_instance_private (self);

if (priv->connect_cancellable != NULL) { /* Již se připojuje */ return; }

/* Nastavení jako zrušitelné */ priv->connect_cancellable = g_cancellable_new ();

/* Čtení adresy soketu */ address_file = build_address_file (); g_file_load_contents_async (address_file, priv->connect_cancellable, connect_to_server_cb1, self); g_object_unref (address_file); }

static void connect_to_server_cb1 (GObject *source_object, GAsyncResult *result, gpointer user_data) { MyObject *self; MyObjectPrivate *priv; GFile *address_file; /* unowned */ gchar *address = NULL; /* owned */ gsize address_size = 0; GInetAddress *inet_address = NULL; /* owned */ GInetSocketAddress *inet_socket_address = NULL; /* owned */ guint16 port = 123; GSocketClient *socket_client = NULL; /* owned */ GError *error = NULL;

address_file = G_FILE (source_object); self = MY_OBJECT (user_data); priv = my_object_get_instance_private (self);

/* Dokončení načítání adresy */ g_file_load_contents_finish (address_file, result, &address, &address_size, NULL, &error);

if (error != NULL) { goto done; }

/* Zpracování adresy */ inet_address = g_inet_address_new_from_string (address);

if (inet_address == NULL) { /* Chyba */ g_set_error (&error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, "Invalid address ‘%s’.", address); goto done; }

inet_socket_address = g_inet_socket_address_new (inet_address, port);

/* Připojení na zadanou adresu */ socket_client = g_socket_client_new ();

g_socket_client_connect_async (socket_client, G_SOCKET_CONNECTABLE (inet_socket_address), priv->connect_cancellable, connect_to_server_cb2, self);

done: if (error != NULL) { /* Zastavení operace */ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_warning ("Failed to load server address: %s", error->message); }

g_clear_object (&priv->connect_cancellable); g_error_free (error); }

g_free (address); g_clear_object (&inet_address); g_clear_object (&inet_socket_address); g_clear_object (&socket_client); }

static void connect_to_server_cb2 (GObject *source_object, GAsyncResult *result, gpointer user_data) { MyObject *self; MyObjectPrivate *priv; GSocketClient *socket_client; /* unowned */ GSocketConnection *connection = NULL; /* owned */ GInputStream *input_stream; /* unowned */ GError *error = NULL;

socket_client = G_SOCKET_CLIENT (source_object); self = MY_OBJECT (user_data); priv = my_object_get_instance_private (self);

/* Dokončení připojování k soketu */ connection = g_socket_client_connect_finish (socket_client, result, &error);

if (error != NULL) { goto done; }

/* Uchování odkazu na připojení, takže je udržované otevřené po dobu co z něj * čteme: #GInputStream neudržuje odkaz na #GIOStream, který jej obsahuje */ priv->connection = g_object_ref (connection);

/* Čtení zprávy z připojení. Používá jedinou vyrovnávací paměť uchovanou v * #MyObject, což znamená, že v danou chvíli může běžet jen jediná operace * connect_to_server(). Pokud je to problém , může být vyrovnávací paměť * místo toho alokována dynamicky. */ input_stream = g_io_stream_get_input_stream (G_IO_STREAM (connection));

g_input_stream_read_async (input_stream, priv->message_buffer, sizeof (priv->message_buffer), G_PRIORITY_DEFAULT, priv->connect_cancellable, connect_to_server_cb3, self);

done: if (error != NULL) { /* Zastavení operace */ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_warning ("Failed to connect to server: %s", error->message); }

g_clear_object (&priv->connect_cancellable); g_clear_object (&priv->connection); g_error_free (error); }

g_clear_object (&connection); }

static void connect_to_server_cb3 (GObject *source_object, GAsyncResult *result, gpointer user_data) { MyObject *self; MyObjectPrivate *priv; GInputStream *input_stream; /* unowned */ gssize len = 0; GError *error = NULL;

input_stream = G_INPUT_STREAM (source_object); self = MY_OBJECT (user_data); priv = my_object_get_instance_private (self);

/* Dokončení čtení ze soketu */ len = g_input_stream_read_finish (input_stream, result, &error);

if (error != NULL) { goto done; }

/* Obsluha zprávy */ g_assert_cmpint (len, >=, 0); g_assert_cmpuint ((gsize) len, <=, sizeof (priv->message_buffer));

handle_received_message (self, priv->message_buffer, len, &error);

if (error != NULL) { goto done; }

done: /* Nepodmíněné označení operace za dokončenou. * * Proud dat by se měl automaticky zavřít, protože * je zahozen poslední odkaz. */ g_clear_object (&priv->connect_cancellable); g_clear_object (&priv->connection);

if (error != NULL) { /* Varování o chybě */ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_warning ("Failed to read from the server: %s", error->message); }

g_error_free (error); } }

static void my_object_dispose (GObject *obj) { MyObjectPrivate *priv;

priv = my_object_get_instance_private (MY_OBJECT (obj));

/* Zrušení případných probíhajících operací mazání. * * Tím se zajistí, že když je #MyObject částečně uvolněn přes * sadu operací delete_files(), sada obdrží zrušení a nepokračuje * s neplatným ukazatelem na #MyObject. */ g_cancellable_cancel (priv->connect_cancellable);

/* Zde proveďte případná další uvolnění */ …

/* Zřetězení */ G_OBJECT_CLASS (my_object_parent_class)->dispose (obj); }

## Operace prováděné paralelně

Jinou běžnou situací je spustit více asynchronních operací souběžně s předpokladem, že celková operace bude dokončena, jakmile všechny její součásti doběhnou.

V tomto příkladu aplikace maže souběžně několik souborů.

Klíčové body v tomto příkladu:

Počet čekajících asynchronních operací (tj. těch, které byly spuštěny a ještě nedoběhly) je sledován v `n_deletions_pending`. Zpětné volání `delete_files_cb()` bere celkovou operaci za dokončenou, až když tato hodnota dosáhne nuly.

`n_deletions_to_start` sleduje spouštění operací mazání, v případě `g_file_delete_async()` spravuje použití rychlé cesty a dokončení synchronně (bez blokování).

Stejně jako v , jsou všechna čekající mazání zrušena v situaci, kdy je vlastnící instance `MyObject` uvolněna, aby se zabránilo pozdějšímu zavolání zpětného volání s neplatným ukazatelem `MyObject`.

static void delete_files_cb (GObject *source_object, GAsyncResult *result, gpointer user_data);

static void delete_files (MyObject *self, GPtrArray/*<owned GFile*>>*/ *files) { MyObjectPrivate *priv; GFile *address_file = NULL; /* owned */

priv = my_object_get_instance_private (self);

/* Nastavení jako zrušitelné, pokud již neběží žádná operace */ if (priv->delete_cancellable == NULL) { priv->delete_cancellable = g_cancellable_new (); priv->n_deletions_pending = 0; priv->n_deletions_total = 0; }

/* Aktualizace interního stavu a dočasné nastavení @n_deletions_to_start. * To se používá v delete_files_cb(), aby se předešlo oznámení, že je celá * operace dokončená, zatím co ona stále běží. To by se mohlo stát, když * g_file_delete_async() doběhne synchronně, například, když existuje * neblokující rychlá cesta pro zadaný souborový systém. */ priv->n_deletions_pending += files->len; priv->n_deletions_total += files->len; priv->n_deletions_to_start = files->len;

/* Aktulazice uživatelského rozhraní, aby dalo najevo, že je soubor mazán */ update_ui_to_show_progress (self, priv->n_deletions_pending, priv->n_deletions_total);

/* Začne souběžně všechny operace mazání. Sdílejí stejný #GCancellable. */ for (i = 0; i < files->len; i++) { GFile *file = files->pdata[i];

priv->n_deletions_to_start--; g_file_delete_async (file, G_PRIORITY_DEFAULT, priv->delete_cancellable, delete_files_cb, self); } }

static void delete_files_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { MyObject *self; MyObjectPrivate *priv; GFile *file; /* unowned */ GError *error = NULL;

file = G_FILE (source_object); self = MY_OBJECT (user_data); priv = my_object_get_instance_private (self);

/* Dokončení mazání souboru */ g_file_delete_finish (file, result, &error);

if (error != NULL && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_warning ("Error deleting file: %s", error->message); }

g_clear_error (&error);

/* Aktualizace interního stavu */ g_assert_cmpuint (priv->n_deletions_pending, >, 0); priv->n_deletions_pending--;

/* Aktualizace uživatelského rozhraní, aby ukazovalo průběh */ update_ui_to_show_progress (self, priv->n_deletions_pending, priv->n_deletions_total);

/* Jestliže je všechno mazání dokončeno a žádné další nezačíná, aktualizuje se, * uživatelské rozhraní, aby ukazovalo, že je vše dokončeno. */ if (priv->n_deletions_pending == 0 && priv->n_deletions_to_start == 0) { update_ui_to_show_completion (self);

/* Vyčištění stavu operace */ g_clear_object (&priv->delete_cancellable); priv->n_deletions_total = 0; } }

static void my_object_dispose (GObject *obj) { MyObjectPrivate *priv;

priv = my_object_get_instance_private (MY_OBJECT (obj));

/* Zrušení případných probíhajících operací mazání. * * Tím se zajistí, že když je #MyObject částečně uvolněn přes * sadu operací delete_files(), sada obdrží zrušení a nepokračuje * s neplatným ukazatelem na #MyObject. */ g_cancellable_cancel (priv->delete_cancellable);

/* Zde proveďte případná další uvolnění */ …

/* Zřetězení */ G_OBJECT_CLASS (my_object_parent_class)->dispose (obj); }

## Obalení pomocí `GTask`

Asynchronní operace (nebo sady operací) často, když se stanou více komplexními, potřebují přiřazený stav. Ten bývá typicky uchován ve vlastní struktuře, ale definování nové struktury pro uchování standardního zpětného volání, uživatelských dat a n-tice zrušitelných je pracné. `GTask` to zjednodušuje poskytnutím standardního způsobu obalení všech tří věcí, plus navíc vlastními „daty úlohy“.

Použití `GTask` může nahradit použití `GCancellable` pro indikaci, jestli běží nějaká operace.

Tento příklad se z hlediska funkcionality shoduje s , ale je přepracován tak, aby používal `GTask` k obalení posloupnosti operací.

Klíčové body v tomto příkladu:

Stav, který byl v v `MyObjectPrivate`, je nyní uzavřen v `ConnectToServerData`, který je nastaven jako „daty úlohy“ objektu `GTask` představujícího celkovou operaci. To znamená, že je automaticky uvolněn po návratu z operace.

Navíc to znamená, že zacházení se stavem `MyObjectPrivate` je omezeno na začátek a konec posloupnosti operací, takže znovupoužití úlohy v jiné situaci se stává snazší. Například je nyní mnohem snazší podporovat běh více takovýchto úloh souběžně.

Protože `GTask` udržuje odkaz na `MyObject`, není objekt možné uvolnit, když probíhá posloupnost operací. Proto byl kód `my_object_dispose()` odstraněn. Místo něj je teď metoda `my_object_close()`, která umožňuje zrušení případných čekajících operací, takže `MyObject` může být v případě potřeby uvolněn.

static void connect_to_server_cb1 (GObject *source_object, GAsyncResult *result, gpointer user_data); static void connect_to_server_cb2 (GObject *source_object, GAsyncResult *result, gpointer user_data); static void connect_to_server_cb3 (GObject *source_object, GAsyncResult *result, gpointer user_data);

typedef struct { GSocketConnection *connection; /* nullable; owned */ guint8 message_buffer[128]; } ConnectToServerData;

static void connect_to_server_data_free (ConnectToServerData *data) { g_clear_object (&data->connection); }

void my_object_connect_to_server_async (MyObject *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { MyObjectPrivate *priv; GTask *task = NULL; /* owned */ ConnectToServerData *data = NULL; /* owned */ GFile *address_file = NULL; /* owned */

g_return_if_fail (MY_IS_OBJECT (self)); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));

priv = my_object_get_instance_private (self);

if (priv->connect_task != NULL) { g_task_report_new_error (self, callback, user_data, NULL, G_IO_ERROR, G_IO_ERROR_PENDING, "Already connecting to the server."); return; }

/* Nastavení, že je zrušitelné */ if (cancellable != NULL) { g_object_ref (cancellable); } else { cancellable = g_cancellable_new (); }

/* Nastavení úlohy */ task = g_task_new (self, cancellable, callback, user_data); g_task_set_check_cancellable (task, FALSE);

data = g_malloc0 (sizeof (ConnectToServerData)); g_task_set_task_data (task, data, (GDestroyNotify) connect_to_server_data_free);

g_object_unref (cancellable);

priv->connect_task = g_object_ref (task);

/* Čtení adresy soketu */ address_file = build_address_file (); g_file_load_contents_async (address_file, g_task_get_cancellable (task), connect_to_server_cb1, g_object_ref (task)); g_object_unref (address_file);

g_clear_object (&task); }

static void connect_to_server_cb1 (GObject *source_object, GAsyncResult *result, gpointer user_data) { MyObject *self; MyObjectPrivate *priv; GTask *task = NULL; /* owned */ GFile *address_file; /* unowned */ gchar *address = NULL; /* owned */ gsize address_size = 0; GInetAddress *inet_address = NULL; /* owned */ GInetSocketAddress *inet_socket_address = NULL; /* owned */ guint16 port = 123; GSocketClient *socket_client = NULL; /* owned */ GError *error = NULL;

address_file = G_FILE (source_object); task = G_TASK (user_data); self = g_task_get_source_object (task); priv = my_object_get_instance_private (self);

/* Dokončení načtení adresy */ g_file_load_contents_finish (address_file, result, &address, &address_size, NULL, &error);

if (error != NULL) { goto done; }

/* Zpracování adresy */ inet_address = g_inet_address_new_from_string (address);

if (inet_address == NULL) { /* Chyba */ g_set_error (&error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, "Invalid address ‘%s’.", address); goto done; }

inet_socket_address = g_inet_socket_address_new (inet_address, port);

/* Připojení k zadané adrese */ socket_client = g_socket_client_new ();

g_socket_client_connect_async (socket_client, G_SOCKET_CONNECTABLE (inet_socket_address), g_task_get_cancellable (task), connect_to_server_cb2, g_object_ref (task));

done: if (error != NULL) { /* Zastavení operace a propagace chyby */ g_clear_object (&priv->connect_task); g_task_return_error (task, error); }

g_free (address); g_clear_object (&inet_address); g_clear_object (&inet_socket_address); g_clear_object (&socket_client); g_clear_object (&task); }

static void connect_to_server_cb2 (GObject *source_object, GAsyncResult *result, gpointer user_data) { MyObject *self; MyObjectPrivate *priv; GTask *task = NULL; /* owned */ ConnectToServerData *data; /* unowned */ GSocketClient *socket_client; /* unowned */ GSocketConnection *connection = NULL; /* owned */ GInputStream *input_stream; /* unowned */ GError *error = NULL;

socket_client = G_SOCKET_CLIENT (source_object); task = G_TASK (user_data); data = g_task_get_task_data (task); self = g_task_get_source_object (task); priv = my_object_get_instance_private (self);

/* Dokončení připojení k soketu */ connection = g_socket_client_connect_finish (socket_client, result, &error);

if (error != NULL) { goto done; }

/* Uchování odkazu na připojení, takže je udržované otevřené po dobu co z něj * čteme: #GInputStream neudržuje odkaz na #GIOStream, který jej obsahuje */ data->connection = g_object_ref (connection);

/* Čtení zprávy z připojení. Protože je vyrovnávací paměť alokovaná jako * součást @data pro jednotlivé úlohy, může běžet víc úloh naráz. */ input_stream = g_io_stream_get_input_stream (G_IO_STREAM (connection));

g_input_stream_read_async (input_stream, data->message_buffer, sizeof (data->message_buffer), G_PRIORITY_DEFAULT, g_task_get_cancellable (task), connect_to_server_cb3, g_object_ref (task));

done: if (error != NULL) { /* Zastavení operace a propagace chyby */ g_clear_object (&priv->connect_task); g_task_return_error (task, error); }

g_clear_object (&connection); g_clear_object (&task); }

static void connect_to_server_cb3 (GObject *source_object, GAsyncResult *result, gpointer user_data) { MyObject *self; MyObjectPrivate *priv; GTask *task = NULL; /* owned */ ConnectToServerData *data; /* unowned */ GInputStream *input_stream; /* unowned */ gssize len = 0; GError *error = NULL;

input_stream = G_INPUT_STREAM (source_object); task = G_TASK (user_data); data = g_task_get_task_data (task); self = g_task_get_source_object (task); priv = my_object_get_instance_private (self);

/* Dokončení čtení ze soketu */ len = g_input_stream_read_finish (input_stream, result, &error);

if (error != NULL) { goto done; }

/* Obsluha zprávy */ g_assert_cmpint (len, >=, 0); g_assert_cmpuint ((gsize) len, <=, sizeof (data->message_buffer));

handle_received_message (self, data->message_buffer, len, &error);

if (error != NULL) { goto done; }

/* Úspěch! */ g_task_return_boolean (task, TRUE);

done: /* Nepodmíněné označení operace za dokončenou. * * Proud dat by se měl automaticky zavřít, protože * je zahozen poslední odkaz. */ g_clear_object (&priv->connect_task);

if (error != NULL) { /* Zastavení operace a propagace chyby */ g_task_return_error (task, error); }

g_clear_object (&task); }

void my_object_connect_to_server_finish (MyObject *self, GAsyncResult *result, GError **error) { g_return_if_fail (MY_IS_OBJECT (self)); g_return_if_fail (g_task_is_valid (result, self)); g_return_if_fail (error == NULL || *error == NULL);

g_task_propagate_boolean (G_TASK (result), error); }

void my_object_close (MyObject *self) { MyObjectPrivate *priv;

g_return_if_fail (MY_IS_OBJECT (self));

priv = my_object_get_instance_private (self);

if (priv->connect_task != NULL) { GCancellable *cancellable = g_task_get_cancellable (priv->connect_task); g_cancellable_cancel (cancellable); } }