LCOV - code coverage report
Current view: top level - src/plugins/notification - valent-notification-upload.c (source / functions) Coverage Total Hit
Test: Code Coverage Lines: 79.7 % 197 157
Test Date: 2024-04-13 23:00:06 Functions: 93.8 % 16 15
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 44.3 % 176 78

             Branch data     Line data    Source code
       1                 :             : // SPDX-License-Identifier: GPL-3.0-or-later
       2                 :             : // SPDX-FileCopyrightText: Andy Holmes <andrew.g.r.holmes@gmail.com>
       3                 :             : 
       4                 :             : #define G_LOG_DOMAIN "valent-notification-upload"
       5                 :             : 
       6                 :             : #include "config.h"
       7                 :             : 
       8                 :             : #include <gio/gio.h>
       9                 :             : #include <gtk/gtk.h>
      10                 :             : #include <json-glib/json-glib.h>
      11                 :             : #include <valent.h>
      12                 :             : 
      13                 :             : #include "valent-notification-upload.h"
      14                 :             : 
      15                 :             : #define DEFAULT_ICON_SIZE 512
      16                 :             : 
      17                 :             : 
      18                 :             : /**
      19                 :             :  * ValentNotificationUpload:
      20                 :             :  *
      21                 :             :  * A class for notification icon uploads.
      22                 :             :  *
      23                 :             :  * `ValentNotificationUpload` is a class that abstracts uploading notifications
      24                 :             :  * with icon payloads for `ValentNotificationPlugin`.
      25                 :             :  */
      26                 :             : 
      27                 :             : struct _ValentNotificationUpload
      28                 :             : {
      29                 :             :   ValentTransfer  parent_instance;
      30                 :             : 
      31                 :             :   ValentDevice   *device;
      32                 :             :   JsonNode       *packet;
      33                 :             :   GIcon          *icon;
      34                 :             : };
      35                 :             : 
      36   [ +  +  +  - ]:          14 : G_DEFINE_FINAL_TYPE (ValentNotificationUpload, valent_notification_upload, VALENT_TYPE_TRANSFER)
      37                 :             : 
      38                 :             : enum {
      39                 :             :   PROP_0,
      40                 :             :   PROP_DEVICE,
      41                 :             :   PROP_ICON,
      42                 :             :   PROP_PACKET,
      43                 :             :   N_PROPERTIES,
      44                 :             : };
      45                 :             : 
      46                 :             : static GParamSpec *properties[N_PROPERTIES] = { 0, };
      47                 :             : 
      48                 :             : 
      49                 :             : /*
      50                 :             :  * GIcon Helpers
      51                 :             :  */
      52                 :             : static GtkIconTheme *
      53                 :           2 : _gtk_icon_theme_get_default (void)
      54                 :             : {
      55                 :           2 :   static GtkIconTheme *icon_theme = NULL;
      56                 :           2 :   size_t guard = 0;
      57                 :             : 
      58   [ +  -  +  - ]:           2 :   if (g_once_init_enter (&guard))
      59                 :             :     {
      60         [ +  - ]:           2 :       if (gtk_is_initialized ())
      61                 :             :         {
      62                 :           2 :           GdkDisplay *display = NULL;
      63                 :             : 
      64         [ +  - ]:           2 :           if ((display = gdk_display_get_default ()) != NULL)
      65                 :           2 :             icon_theme = gtk_icon_theme_get_for_display (display);
      66                 :             :         }
      67                 :             : 
      68                 :           2 :       g_once_init_leave (&guard, 1);
      69                 :             :     }
      70                 :             : 
      71                 :           2 :   return icon_theme;
      72                 :             : }
      73                 :             : 
      74                 :             : static int
      75                 :           2 : _gtk_icon_theme_get_largest_icon (GtkIconTheme *theme,
      76                 :             :                                   const char   *name)
      77                 :             : {
      78                 :           4 :   g_autofree int *sizes = NULL;
      79                 :           2 :   int ret = 0;
      80                 :             : 
      81   [ +  -  +  -  :           2 :   g_assert (GTK_IS_ICON_THEME (theme));
             -  +  -  - ]
      82         [ -  + ]:           2 :   g_assert (name != NULL);
      83                 :             : 
      84         [ +  - ]:           2 :   if (!gtk_icon_theme_has_icon (theme, name))
      85                 :             :     return ret;
      86                 :             : 
      87                 :           2 :   sizes = gtk_icon_theme_get_icon_sizes (theme, name);
      88                 :             : 
      89         [ +  - ]:           2 :   for (unsigned int i = 0; sizes[i] != 0; i++)
      90                 :             :     {
      91         [ -  + ]:           2 :       if (sizes[i] == -1)
      92                 :             :         return -1;
      93                 :             : 
      94                 :           0 :       if (sizes[i] > ret)
      95                 :             :         ret = sizes[i];
      96                 :             :     }
      97                 :             : 
      98                 :             :   return ret;
      99                 :             : }
     100                 :             : 
     101                 :             : static GFile *
     102                 :           2 : get_largest_icon_file (GIcon *icon)
     103                 :             : {
     104                 :           2 :   GtkIconTheme *icon_theme = NULL;
     105                 :           2 :   const char * const *names;
     106                 :           4 :   g_autoptr (GtkIconPaintable) info = NULL;
     107                 :             : 
     108   [ +  -  +  -  :           2 :   g_assert (G_IS_THEMED_ICON (icon));
             -  +  -  - ]
     109                 :             : 
     110                 :           2 :   icon_theme = _gtk_icon_theme_get_default ();
     111                 :             : 
     112         [ +  - ]:           2 :   if (icon_theme == NULL)
     113                 :             :     return NULL;
     114                 :             : 
     115                 :           2 :   names = g_themed_icon_get_names (G_THEMED_ICON (icon));
     116                 :             : 
     117         [ +  - ]:           2 :   for (unsigned int i = 0; names[i]; i++)
     118                 :             :     {
     119                 :           2 :       int size;
     120                 :             : 
     121         [ -  + ]:           2 :       if ((size = _gtk_icon_theme_get_largest_icon (icon_theme, names[i])) == 0)
     122                 :           0 :         continue;
     123                 :             : 
     124                 :           2 :       info = gtk_icon_theme_lookup_icon (icon_theme,
     125                 :             :                                          names[i],
     126                 :             :                                          NULL,
     127                 :             :                                          size,
     128                 :             :                                          1,
     129                 :             :                                          GTK_TEXT_DIR_NONE,
     130                 :             :                                          0);
     131                 :             : 
     132         [ +  - ]:           2 :       if (info != NULL)
     133                 :           2 :         return gtk_icon_paintable_get_file (info);
     134                 :             :     }
     135                 :             : 
     136                 :             :   return NULL;
     137                 :             : }
     138                 :             : 
     139                 :             : static void
     140                 :           6 : on_size_prepared (GdkPixbufLoader *loader,
     141                 :             :                   int              width,
     142                 :             :                   int              height,
     143                 :             :                   gpointer         user_data)
     144                 :             : {
     145                 :           6 :   GdkPixbufFormat *format = gdk_pixbuf_loader_get_format (loader);
     146                 :             : 
     147         [ +  + ]:           6 :   if (!gdk_pixbuf_format_is_scalable (format))
     148                 :             :     return;
     149                 :             : 
     150         [ +  - ]:           4 :   if (width >= DEFAULT_ICON_SIZE || height >= DEFAULT_ICON_SIZE)
     151                 :             :     return;
     152                 :             : 
     153                 :           4 :   gdk_pixbuf_loader_set_size (loader, DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE);
     154                 :             : }
     155                 :             : 
     156                 :             : static GBytes *
     157                 :           4 : valent_notification_upload_get_icon_bytes (GIcon         *icon,
     158                 :             :                                            GCancellable  *cancellable,
     159                 :             :                                            GError       **error)
     160                 :             : {
     161                 :           8 :   g_autoptr (GBytes) bytes = NULL;
     162         [ +  - ]:           4 :   g_autoptr (GdkPixbufLoader) loader = NULL;
     163                 :           4 :   GdkPixbuf *pixbuf = NULL;
     164         [ +  - ]:           4 :   g_autoptr (GError) warn = NULL;
     165                 :           4 :   char *data;
     166                 :           4 :   size_t size;
     167                 :             : 
     168   [ +  -  +  -  :           4 :   g_assert (G_IS_ICON (icon));
             +  -  -  + ]
     169   [ +  -  +  -  :           4 :   g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  +  -  - ]
     170   [ +  -  -  + ]:           4 :   g_assert (error == NULL || *error == NULL);
     171                 :             : 
     172                 :             :   /* First try to get the bytes of the GIcon */
     173   [ +  -  +  +  :           4 :   if (G_IS_THEMED_ICON (icon))
                   -  + ]
     174                 :             :     {
     175                 :           2 :       g_autoptr (GFile) file = NULL;
     176                 :             : 
     177                 :           2 :       file = get_largest_icon_file (icon);
     178                 :             : 
     179         [ -  + ]:           2 :       if (file == NULL)
     180                 :             :         {
     181                 :           0 :           g_set_error (error,
     182                 :             :                        G_IO_ERROR,
     183                 :             :                        G_IO_ERROR_FAILED,
     184                 :             :                        "Failed to load themed icon");
     185                 :           0 :           return NULL;
     186                 :             :         }
     187                 :             : 
     188                 :           2 :       bytes = g_file_load_bytes (file, cancellable, NULL, error);
     189                 :             :     }
     190   [ +  -  +  +  :           2 :   else if (G_IS_FILE_ICON (icon))
                   -  + ]
     191                 :             :     {
     192                 :           1 :       GFile *file;
     193                 :             : 
     194                 :           1 :       file = g_file_icon_get_file (G_FILE_ICON (icon));
     195                 :           1 :       bytes = g_file_load_bytes (file, cancellable, NULL, error);
     196                 :             :     }
     197   [ +  -  -  +  :           1 :   else if (G_IS_BYTES_ICON (icon))
                   -  - ]
     198                 :             :     {
     199                 :           1 :       GBytes *buffer;
     200                 :             : 
     201                 :           1 :       buffer = g_bytes_icon_get_bytes (G_BYTES_ICON (icon));
     202                 :             : 
     203         [ -  + ]:           1 :       if (buffer == NULL)
     204                 :             :         {
     205                 :           0 :           g_set_error (error,
     206                 :             :                        G_IO_ERROR,
     207                 :             :                        G_IO_ERROR_FAILED,
     208                 :             :                        "Failed to load icon bytes");
     209                 :           0 :           return NULL;
     210                 :             :         }
     211                 :             : 
     212                 :           1 :       bytes = g_bytes_ref (buffer);
     213                 :             :     }
     214   [ #  #  #  #  :           0 :   else if (GDK_IS_PIXBUF (icon))
                   #  # ]
     215                 :             :     {
     216                 :           0 :       bytes = gdk_pixbuf_read_pixel_bytes (GDK_PIXBUF (icon));
     217                 :             :     }
     218                 :             : 
     219         [ -  + ]:           4 :   if (bytes == NULL)
     220                 :           0 :     return NULL;
     221                 :             : 
     222                 :             :   /* Now attempt to load the bytes as a pixbuf */
     223                 :           4 :   loader = gdk_pixbuf_loader_new ();
     224                 :             : 
     225                 :           4 :   g_signal_connect_object (loader,
     226                 :             :                            "size-prepared",
     227                 :             :                            G_CALLBACK (on_size_prepared),
     228                 :             :                            NULL, 0);
     229                 :             : 
     230   [ +  -  -  + ]:           8 :   if (!gdk_pixbuf_loader_write_bytes (loader, bytes, &warn) ||
     231                 :           4 :       !gdk_pixbuf_loader_close (loader, &warn))
     232                 :             :     {
     233                 :           0 :       g_debug ("%s(): %s", G_STRFUNC, warn->message);
     234                 :           0 :       return g_steal_pointer (&bytes);
     235                 :             :     }
     236                 :             : 
     237         [ -  + ]:           4 :   if ((pixbuf = gdk_pixbuf_loader_get_pixbuf (loader)) == NULL)
     238                 :             :     {
     239                 :           0 :       g_debug ("%s(): Failed to create pixbuf from bytes", G_STRFUNC);
     240                 :           0 :       return g_steal_pointer (&bytes);
     241                 :             :     }
     242                 :             : 
     243         [ -  + ]:           4 :   if (!gdk_pixbuf_save_to_buffer (pixbuf, &data, &size, "png", &warn, NULL))
     244                 :             :     {
     245                 :           0 :       g_debug ("%s(): %s", G_STRFUNC, warn->message);
     246                 :           0 :       return g_steal_pointer (&bytes);
     247                 :             :     }
     248                 :             : 
     249                 :           4 :   return g_bytes_new_take (data, size);
     250                 :             : }
     251                 :             : 
     252                 :             : /*
     253                 :             :  * ValentTransfer
     254                 :             :  */
     255                 :             : static void
     256                 :           4 : valent_notification_upload_execute_task (GTask        *task,
     257                 :             :                                          gpointer      source_object,
     258                 :             :                                          gpointer      task_data,
     259                 :             :                                          GCancellable *cancellable)
     260                 :             : {
     261                 :           4 :   ValentNotificationUpload *self = VALENT_NOTIFICATION_UPLOAD (source_object);
     262                 :           4 :   g_autoptr (ValentChannel) channel = NULL;
     263         [ -  - ]:           4 :   g_autoptr (GIcon) icon = NULL;
     264   [ +  -  -  - ]:           4 :   g_autoptr (JsonNode) packet = NULL;
     265   [ +  -  -  - ]:           4 :   g_autoptr (GBytes) bytes = NULL;
     266         [ -  - ]:           4 :   g_autoptr (GIOStream) target = NULL;
     267         [ -  - ]:           4 :   g_autofree char *payload_hash = NULL;
     268                 :           4 :   const uint8_t *payload_data = NULL;
     269                 :           4 :   size_t payload_size = 0;
     270                 :           4 :   gboolean ret = FALSE;
     271                 :           4 :   GError *error = NULL;
     272                 :             : 
     273         [ +  - ]:           4 :   g_assert (VALENT_IS_NOTIFICATION_UPLOAD (self));
     274                 :             : 
     275         [ +  - ]:           4 :   if (g_task_return_error_if_cancelled (task))
     276                 :             :     return;
     277                 :             : 
     278                 :           4 :   valent_object_lock (VALENT_OBJECT (self));
     279                 :           4 :   channel = valent_device_ref_channel (self->device);
     280                 :           4 :   icon = g_object_ref (self->icon);
     281                 :           4 :   packet = json_node_ref (self->packet);
     282                 :           4 :   valent_object_unlock (VALENT_OBJECT (self));
     283                 :             : 
     284         [ -  + ]:           4 :   if (channel == NULL)
     285                 :             :     {
     286                 :           0 :       g_task_return_new_error (task,
     287                 :             :                                G_IO_ERROR,
     288                 :             :                                G_IO_ERROR_NOT_CONNECTED,
     289                 :             :                                "Device is disconnected");
     290                 :           0 :       return;
     291                 :             :     }
     292                 :             : 
     293                 :             :   /* Try to get the icon bytes */
     294                 :           4 :   bytes = valent_notification_upload_get_icon_bytes (icon, cancellable, &error);
     295                 :             : 
     296         [ -  + ]:           4 :   if (bytes == NULL)
     297                 :           0 :     return g_task_return_error (task, error);
     298                 :             : 
     299                 :             :   /* A payload hash is included, allowing the remote device to ignore icon
     300                 :             :    * transfers that it already has cached. */
     301                 :           4 :   payload_data = g_bytes_get_data (bytes, &payload_size);
     302                 :           4 :   payload_hash = g_compute_checksum_for_data (G_CHECKSUM_MD5,
     303                 :             :                                               payload_data,
     304                 :             :                                               payload_size);
     305                 :           4 :   json_object_set_string_member (valent_packet_get_body (packet),
     306                 :             :                                  "payloadHash",
     307                 :             :                                  payload_hash);
     308                 :           4 :   valent_packet_set_payload_size (packet, payload_size);
     309                 :             : 
     310                 :           4 :   target = valent_channel_upload (channel, packet, cancellable, &error);
     311                 :             : 
     312         [ -  + ]:           4 :   if (target == NULL)
     313                 :           0 :     return g_task_return_error (task, error);
     314                 :             : 
     315                 :             :   /* Upload the icon */
     316                 :           4 :   ret = g_output_stream_write_all (g_io_stream_get_output_stream (target),
     317                 :             :                                    payload_data,
     318                 :             :                                    payload_size,
     319                 :             :                                    NULL,
     320                 :             :                                    cancellable,
     321                 :             :                                    &error);
     322                 :             : 
     323         [ -  + ]:           4 :   if (!ret)
     324                 :           0 :     return g_task_return_error (task, error);
     325                 :             : 
     326                 :           4 :   g_task_return_boolean (task, TRUE);
     327                 :             : }
     328                 :             : 
     329                 :             : static void
     330                 :           4 : valent_notification_upload_execute (ValentTransfer      *transfer,
     331                 :             :                                     GCancellable        *cancellable,
     332                 :             :                                     GAsyncReadyCallback  callback,
     333                 :             :                                     gpointer             user_data)
     334                 :             : {
     335                 :           8 :   g_autoptr (GTask) task = NULL;
     336                 :             : 
     337         [ +  - ]:           4 :   g_assert (VALENT_IS_NOTIFICATION_UPLOAD (transfer));
     338   [ +  -  +  -  :           4 :   g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
             -  +  -  - ]
     339                 :             : 
     340                 :           4 :   task = g_task_new (transfer, cancellable, callback, user_data);
     341         [ +  - ]:           4 :   g_task_set_source_tag (task, valent_notification_upload_execute);
     342         [ +  - ]:           4 :   g_task_run_in_thread (task, valent_notification_upload_execute_task);
     343                 :           4 : }
     344                 :             : 
     345                 :             : /*
     346                 :             :  * GObject
     347                 :             :  */
     348                 :             : static void
     349                 :           4 : valent_notification_upload_finalize (GObject *object)
     350                 :             : {
     351                 :           4 :   ValentNotificationUpload *self = VALENT_NOTIFICATION_UPLOAD (object);
     352                 :             : 
     353                 :           4 :   valent_object_lock (VALENT_OBJECT (self));
     354         [ +  - ]:           4 :   g_clear_object (&self->device);
     355         [ +  - ]:           4 :   g_clear_object (&self->icon);
     356         [ +  - ]:           4 :   g_clear_pointer (&self->packet, json_node_unref);
     357                 :           4 :   valent_object_unlock (VALENT_OBJECT (self));
     358                 :             : 
     359                 :           4 :   G_OBJECT_CLASS (valent_notification_upload_parent_class)->finalize (object);
     360                 :           4 : }
     361                 :             : 
     362                 :             : static void
     363                 :           0 : valent_notification_upload_get_property (GObject    *object,
     364                 :             :                                          guint       prop_id,
     365                 :             :                                          GValue     *value,
     366                 :             :                                          GParamSpec *pspec)
     367                 :             : {
     368                 :           0 :   ValentNotificationUpload *self = VALENT_NOTIFICATION_UPLOAD (object);
     369                 :             : 
     370   [ #  #  #  # ]:           0 :   switch (prop_id)
     371                 :             :     {
     372                 :             :     case PROP_DEVICE:
     373                 :           0 :       valent_object_lock (VALENT_OBJECT (self));
     374                 :           0 :       g_value_set_object (value, self->device);
     375                 :           0 :       valent_object_unlock (VALENT_OBJECT (self));
     376                 :           0 :       break;
     377                 :             : 
     378                 :             :     case PROP_ICON:
     379                 :           0 :       valent_object_lock (VALENT_OBJECT (self));
     380                 :           0 :       g_value_set_object (value, self->icon);
     381                 :           0 :       valent_object_unlock (VALENT_OBJECT (self));
     382                 :           0 :       break;
     383                 :             : 
     384                 :             :     case PROP_PACKET:
     385                 :           0 :       valent_object_lock (VALENT_OBJECT (self));
     386                 :           0 :       g_value_set_boxed (value, self->packet);
     387                 :           0 :       valent_object_unlock (VALENT_OBJECT (self));
     388                 :           0 :       break;
     389                 :             : 
     390                 :           0 :     default:
     391                 :           0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     392                 :             :     }
     393                 :           0 : }
     394                 :             : 
     395                 :             : static void
     396                 :          12 : valent_notification_upload_set_property (GObject      *object,
     397                 :             :                                          guint         prop_id,
     398                 :             :                                          const GValue *value,
     399                 :             :                                          GParamSpec   *pspec)
     400                 :             : {
     401                 :          12 :   ValentNotificationUpload *self = VALENT_NOTIFICATION_UPLOAD (object);
     402                 :             : 
     403   [ +  +  +  - ]:          12 :   switch (prop_id)
     404                 :             :     {
     405                 :             :     case PROP_DEVICE:
     406                 :           4 :       valent_object_lock (VALENT_OBJECT (self));
     407                 :           4 :       self->device = g_value_dup_object (value);
     408                 :           4 :       valent_object_unlock (VALENT_OBJECT (self));
     409                 :           4 :       break;
     410                 :             : 
     411                 :             :     case PROP_ICON:
     412                 :           4 :       valent_object_lock (VALENT_OBJECT (self));
     413                 :           4 :       self->icon = g_value_dup_object (value);
     414                 :           4 :       valent_object_unlock (VALENT_OBJECT (self));
     415                 :           4 :       break;
     416                 :             : 
     417                 :             :     case PROP_PACKET:
     418                 :           4 :       valent_object_lock (VALENT_OBJECT (self));
     419                 :           4 :       self->packet = g_value_dup_boxed (value);
     420                 :           4 :       valent_object_unlock (VALENT_OBJECT (self));
     421                 :           4 :       break;
     422                 :             : 
     423                 :           0 :     default:
     424                 :           0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     425                 :             :     }
     426                 :          12 : }
     427                 :             : 
     428                 :             : static void
     429                 :           1 : valent_notification_upload_class_init (ValentNotificationUploadClass *klass)
     430                 :             : {
     431                 :           1 :   GObjectClass *object_class = G_OBJECT_CLASS (klass);
     432                 :           1 :   ValentTransferClass *transfer_class = VALENT_TRANSFER_CLASS (klass);
     433                 :             : 
     434                 :           1 :   object_class->finalize = valent_notification_upload_finalize;
     435                 :           1 :   object_class->get_property = valent_notification_upload_get_property;
     436                 :           1 :   object_class->set_property = valent_notification_upload_set_property;
     437                 :             : 
     438                 :           1 :   transfer_class->execute = valent_notification_upload_execute;
     439                 :             : 
     440                 :             :   /**
     441                 :             :    * ValentNotificationUpload:device:
     442                 :             :    *
     443                 :             :    * The [class@Valent.Device] this transfer is for.
     444                 :             :    */
     445                 :           2 :   properties [PROP_DEVICE] =
     446                 :           1 :     g_param_spec_object ("device", NULL, NULL,
     447                 :             :                          VALENT_TYPE_DEVICE,
     448                 :             :                          (G_PARAM_READWRITE |
     449                 :             :                           G_PARAM_CONSTRUCT_ONLY |
     450                 :             :                           G_PARAM_EXPLICIT_NOTIFY |
     451                 :             :                           G_PARAM_STATIC_STRINGS));
     452                 :             : 
     453                 :             :   /**
     454                 :             :    * ValentNotificationUpload:icon:
     455                 :             :    *
     456                 :             :    * The [iface@Gio.Icon] for the notification.
     457                 :             :    */
     458                 :           2 :   properties [PROP_ICON] =
     459                 :           1 :     g_param_spec_object ("icon", NULL, NULL,
     460                 :             :                          G_TYPE_ICON,
     461                 :             :                          (G_PARAM_READWRITE |
     462                 :             :                           G_PARAM_CONSTRUCT_ONLY |
     463                 :             :                           G_PARAM_EXPLICIT_NOTIFY |
     464                 :             :                           G_PARAM_STATIC_STRINGS));
     465                 :             : 
     466                 :             :   /**
     467                 :             :    * ValentNotificationUpload:packet:
     468                 :             :    *
     469                 :             :    * The packet to send the payload with.
     470                 :             :    */
     471                 :           2 :   properties [PROP_PACKET] =
     472                 :           1 :     g_param_spec_boxed ("packet", NULL, NULL,
     473                 :             :                         JSON_TYPE_NODE,
     474                 :             :                         (G_PARAM_READWRITE |
     475                 :             :                          G_PARAM_CONSTRUCT_ONLY |
     476                 :             :                          G_PARAM_EXPLICIT_NOTIFY |
     477                 :             :                          G_PARAM_STATIC_STRINGS));
     478                 :             : 
     479                 :           1 :   g_object_class_install_properties (object_class, N_PROPERTIES, properties);
     480                 :           1 : }
     481                 :             : 
     482                 :             : static void
     483                 :           4 : valent_notification_upload_init (ValentNotificationUpload *self)
     484                 :             : {
     485                 :           4 : }
     486                 :             : 
     487                 :             : /**
     488                 :             :  * valent_notification_upload_new:
     489                 :             :  * @device: a `ValentDevice`
     490                 :             :  * @packet: a KDE Connect packet
     491                 :             :  * @icon: a `GIcon`
     492                 :             :  *
     493                 :             :  * Create a new `ValentNotificationUpload` for @packet and @icon.
     494                 :             :  *
     495                 :             :  * Returns: (transfer full): a `ValentNotificationUpload`
     496                 :             :  */
     497                 :             : ValentTransfer *
     498                 :           4 : valent_notification_upload_new (ValentDevice *device,
     499                 :             :                                 JsonNode     *packet,
     500                 :             :                                 GIcon        *icon)
     501                 :             : {
     502         [ +  - ]:           4 :   g_return_val_if_fail (VALENT_IS_DEVICE (device), NULL);
     503         [ -  + ]:           4 :   g_return_val_if_fail (VALENT_IS_PACKET (packet), NULL);
     504   [ +  -  +  -  :           4 :   g_return_val_if_fail (G_IS_ICON (icon), NULL);
             +  -  -  + ]
     505                 :             : 
     506                 :           4 :   return g_object_new (VALENT_TYPE_NOTIFICATION_UPLOAD,
     507                 :             :                        "device", device,
     508                 :             :                        "icon",   icon,
     509                 :             :                        "packet", packet,
     510                 :             :                        NULL);
     511                 :             : }
     512                 :             : 
        

Generated by: LCOV version 2.0-1