gdrive.c 24.1 KB
Newer Older
1 2 3 4 5 6 7
/* GIO - GLib Input, Output and Streaming Library
 * 
 * Copyright (C) 2006-2007 Red Hat, Inc.
 *
 * This library 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
8
 * version 2.1 of the License, or (at your option) any later version.
9 10 11 12 13 14 15
 *
 * This library 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
16
 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 18
 *
 * Author: Alexander Larsson <alexl@redhat.com>
19
 *         David Zeuthen <davidz@redhat.com>
20 21
 */

22
#include "config.h"
23
#include "gdrive.h"
24
#include "gtask.h"
25
#include "gthemedicon.h"
26 27
#include "gasyncresult.h"
#include "gioerror.h"
28 29
#include "glibintl.h"

30

31 32
/**
 * SECTION:gdrive
33
 * @short_description: Drive management
Matthias Clasen's avatar
Matthias Clasen committed
34
 * @include: gio/gio.h
35
 *
36
 * #GDrive - this represent a piece of hardware connected to the machine.
37
 * It's generally only created for removable hardware or hardware with
38
 * removable media.
39
 *
40 41 42
 * #GDrive is a container class for #GVolume objects that stem from
 * the same piece of media. As such, #GDrive abstracts a drive with
 * (or without) removable media and provides operations for querying
43
 * whether media is available, determining whether media change is
44 45 46 47 48 49 50
 * automatically detected and ejecting the media.
 *
 * If the #GDrive reports that media isn't automatically detected, one
 * can poll for media; typically one should not do this periodically
 * as a poll for media operation is potententially expensive and may
 * spin up the drive creating noise.
 *
51 52 53 54 55 56 57 58 59
 * #GDrive supports starting and stopping drives with authentication
 * support for the former. This can be used to support a diverse set
 * of use cases including connecting/disconnecting iSCSI devices,
 * powering down external disk enclosures and starting/stopping
 * multi-disk devices such as RAID devices. Note that the actual
 * semantics and side-effects of starting/stopping a #GDrive may vary
 * according to implementation. To choose the correct verbs in e.g. a
 * file manager, use g_drive_get_start_stop_type().
 *
60 61
 * For porting from GnomeVFS note that there is no equivalent of
 * #GDrive in that API.
62 63
 **/

64 65
typedef GDriveIface GDriveInterface;
G_DEFINE_INTERFACE(GDrive, g_drive, G_TYPE_OBJECT)
66 67

static void
68
g_drive_default_init (GDriveInterface *iface)
69
{
70 71 72 73 74 75 76 77 78 79 80
  /**
   * GDrive::changed:
   * @drive: a #GDrive.
   *
   * Emitted when the drive's state has changed.
   **/
  g_signal_new (I_("changed"),
		G_TYPE_DRIVE,
		G_SIGNAL_RUN_LAST,
		G_STRUCT_OFFSET (GDriveIface, changed),
		NULL, NULL,
81
		NULL,
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
		G_TYPE_NONE, 0);

  /**
   * GDrive::disconnected:
   * @drive: a #GDrive.
   *
   * This signal is emitted when the #GDrive have been
   * disconnected. If the recipient is holding references to the
   * object they should release them so the object can be
   * finalized.
   **/
  g_signal_new (I_("disconnected"),
		G_TYPE_DRIVE,
		G_SIGNAL_RUN_LAST,
		G_STRUCT_OFFSET (GDriveIface, disconnected),
		NULL, NULL,
98
		NULL,
99 100 101 102 103 104 105 106 107 108 109 110 111 112
		G_TYPE_NONE, 0);

  /**
   * GDrive::eject-button:
   * @drive: a #GDrive.
   *
   * Emitted when the physical eject button (if any) of a drive has
   * been pressed.
   **/
  g_signal_new (I_("eject-button"),
		G_TYPE_DRIVE,
		G_SIGNAL_RUN_LAST,
		G_STRUCT_OFFSET (GDriveIface, eject_button),
		NULL, NULL,
113
		NULL,
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
		G_TYPE_NONE, 0);

  /**
   * GDrive::stop-button:
   * @drive: a #GDrive.
   *
   * Emitted when the physical stop button (if any) of a drive has
   * been pressed.
   *
   * Since: 2.22
   **/
  g_signal_new (I_("stop-button"),
		G_TYPE_DRIVE,
		G_SIGNAL_RUN_LAST,
		G_STRUCT_OFFSET (GDriveIface, stop_button),
		NULL, NULL,
130
		NULL,
131
		G_TYPE_NONE, 0);
132 133 134 135 136 137
}

/**
 * g_drive_get_name:
 * @drive: a #GDrive.
 * 
Matthias Clasen's avatar
Matthias Clasen committed
138
 * Gets the name of @drive.
139
 *
Matthias Clasen's avatar
Matthias Clasen committed
140 141
 * Returns: a string containing @drive's name. The returned 
 *     string should be freed when no longer needed.
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
 **/
char *
g_drive_get_name (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->get_name) (drive);
}

/**
 * g_drive_get_icon:
 * @drive: a #GDrive.
 * 
 * Gets the icon for @drive.
 * 
161
 * Returns: (transfer full): #GIcon for the @drive.
Matthias Clasen's avatar
Matthias Clasen committed
162
 *    Free the returned object with g_object_unref().
163 164 165 166 167 168 169 170 171 172 173 174 175
 **/
GIcon *
g_drive_get_icon (GDrive *drive)
{
  GDriveIface *iface;
  
  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->get_icon) (drive);
}

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
/**
 * g_drive_get_symbolic_icon:
 * @drive: a #GDrive.
 * 
 * Gets the icon for @drive.
 * 
 * Returns: (transfer full): symbolic #GIcon for the @drive.
 *    Free the returned object with g_object_unref().
 *
 * Since: 2.34
 **/
GIcon *
g_drive_get_symbolic_icon (GDrive *drive)
{
  GDriveIface *iface;
  GIcon *ret;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->get_symbolic_icon != NULL)
    ret = iface->get_symbolic_icon (drive);
  else
    ret = g_themed_icon_new_with_default_fallbacks ("drive-removable-media-symbolic");

  return ret;
}

205 206 207 208
/**
 * g_drive_has_volumes:
 * @drive: a #GDrive.
 * 
209
 * Check if @drive has any mountable volumes.
210
 * 
211
 * Returns: %TRUE if the @drive contains volumes, %FALSE otherwise.
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
 **/
gboolean
g_drive_has_volumes (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->has_volumes) (drive);
}

/**
 * g_drive_get_volumes:
 * @drive: a #GDrive.
 * 
229
 * Get a list of mountable volumes for @drive.
230 231 232
 *
 * The returned list should be freed with g_list_free(), after
 * its elements have been unreffed with g_object_unref().
233
 * 
234
 * Returns: (element-type GVolume) (transfer full): #GList containing any #GVolume objects on the given @drive.
235 236 237 238 239 240 241 242 243 244 245 246 247 248
 **/
GList *
g_drive_get_volumes (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->get_volumes) (drive);
}

/**
249
 * g_drive_is_media_check_automatic:
250 251
 * @drive: a #GDrive.
 * 
252
 * Checks if @drive is capabable of automatically detecting media changes.
253
 * 
Matthias Clasen's avatar
Matthias Clasen committed
254 255
 * Returns: %TRUE if the @drive is capabable of automatically detecting 
 *     media changes, %FALSE otherwise.
256 257
 **/
gboolean
258
g_drive_is_media_check_automatic (GDrive *drive)
259 260 261 262 263 264 265
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

266
  return (* iface->is_media_check_automatic) (drive);
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
/**
 * g_drive_is_removable:
 * @drive: a #GDrive.
 *
 * Checks if the #GDrive and/or its media is considered removable by the user.
 * See g_drive_is_media_removable().
 *
 * Returns: %TRUE if @drive and/or its media is considered removable, %FALSE otherwise.
 *
 * Since: 2.50
 **/
gboolean
g_drive_is_removable (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);
  if (iface->is_removable != NULL)
    return iface->is_removable (drive);

  return FALSE;
}

294
/**
295
 * g_drive_is_media_removable:
296 297
 * @drive: a #GDrive.
 * 
298
 * Checks if the @drive supports removable media.
299
 * 
300
 * Returns: %TRUE if @drive supports removable media, %FALSE otherwise.
301 302
 **/
gboolean
303
g_drive_is_media_removable (GDrive *drive)
304 305 306 307 308 309 310
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

311 312
  return (* iface->is_media_removable) (drive);
}
313

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
/**
 * g_drive_has_media:
 * @drive: a #GDrive.
 * 
 * Checks if the @drive has media. Note that the OS may not be polling
 * the drive for media changes; see g_drive_is_media_check_automatic()
 * for more details.
 * 
 * Returns: %TRUE if @drive has media, %FALSE otherwise.
 **/
gboolean
g_drive_has_media (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->has_media) (drive);
334 335 336 337
}

/**
 * g_drive_can_eject:
Matthias Clasen's avatar
Matthias Clasen committed
338
 * @drive: a #GDrive.
339
 * 
340 341
 * Checks if a drive can be ejected.
 * 
Matthias Clasen's avatar
Matthias Clasen committed
342
 * Returns: %TRUE if the @drive can be ejected, %FALSE otherwise.
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
 **/
gboolean
g_drive_can_eject (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->can_eject == NULL)
    return FALSE;

  return (* iface->can_eject) (drive);
}

/**
360 361 362 363 364
 * g_drive_can_poll_for_media:
 * @drive: a #GDrive.
 * 
 * Checks if a drive can be polled for media changes.
 * 
Matthias Clasen's avatar
Matthias Clasen committed
365 366
 * Returns: %TRUE if the @drive can be polled for media changes,
 *     %FALSE otherwise.
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
 **/
gboolean
g_drive_can_poll_for_media (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->poll_for_media == NULL)
    return FALSE;

  return (* iface->can_poll_for_media) (drive);
}

/**
 * g_drive_eject:
385
 * @drive: a #GDrive.
386
 * @flags: flags affecting the unmount if required for eject
387 388
 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
 * @callback: (nullable): a #GAsyncReadyCallback, or %NULL.
Matthias Clasen's avatar
Matthias Clasen committed
389
 * @user_data: user data to pass to @callback
390
 * 
Matthias Clasen's avatar
Matthias Clasen committed
391 392 393 394 395
 * Asynchronously ejects a drive.
 *
 * When the operation is finished, @callback will be called.
 * You can then call g_drive_eject_finish() to obtain the
 * result of the operation.
396 397
 *
 * Deprecated: 2.22: Use g_drive_eject_with_operation() instead.
398 399
 **/
void
400
g_drive_eject (GDrive              *drive,
401
	       GMountUnmountFlags   flags,
Matthias Clasen's avatar
Matthias Clasen committed
402 403 404
	       GCancellable        *cancellable,
	       GAsyncReadyCallback  callback,
	       gpointer             user_data)
405 406 407 408 409 410 411
{
  GDriveIface *iface;

  g_return_if_fail (G_IS_DRIVE (drive));

  iface = G_DRIVE_GET_IFACE (drive);

412
  if (iface->eject == NULL)
413
    {
414 415 416
      g_task_report_new_error (drive, callback, user_data,
                               g_drive_eject_with_operation,
                               G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
417
                               _("drive doesn’t implement eject"));
418 419 420
      return;
    }
  
421
  (* iface->eject) (drive, flags, cancellable, callback, user_data);
422 423 424
}

/**
Matthias Clasen's avatar
Matthias Clasen committed
425
 * g_drive_eject_finish:
426
 * @drive: a #GDrive.
427
 * @result: a #GAsyncResult.
Matthias Clasen's avatar
Matthias Clasen committed
428
 * @error: a #GError, or %NULL
429
 * 
430
 * Finishes ejecting a drive.
431
 * 
432
 * Returns: %TRUE if the drive has been ejected successfully,
Matthias Clasen's avatar
Matthias Clasen committed
433
 *     %FALSE otherwise.
434 435
 *
 * Deprecated: 2.22: Use g_drive_eject_with_operation_finish() instead.
436 437
 **/
gboolean
438
g_drive_eject_finish (GDrive        *drive,
Matthias Clasen's avatar
Matthias Clasen committed
439 440
		      GAsyncResult  *result,
		      GError       **error)
441 442 443 444 445 446
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);
  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);

447 448
  if (g_async_result_legacy_propagate_error (result, error))
    return FALSE;
449 450
  else if (g_async_result_is_tagged (result, g_drive_eject_with_operation))
    return g_task_propagate_boolean (G_TASK (result), error);
451

452
  iface = G_DRIVE_GET_IFACE (drive);
453 454
  
  return (* iface->eject_finish) (drive, result, error);
455 456
}

457 458 459 460
/**
 * g_drive_eject_with_operation:
 * @drive: a #GDrive.
 * @flags: flags affecting the unmount if required for eject
461
 * @mount_operation: (nullable): a #GMountOperation or %NULL to avoid
462
 *     user interaction.
463 464
 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
 * @callback: (nullable): a #GAsyncReadyCallback, or %NULL.
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
 * @user_data: user data passed to @callback.
 *
 * Ejects a drive. This is an asynchronous operation, and is
 * finished by calling g_drive_eject_with_operation_finish() with the @drive
 * and #GAsyncResult data returned in the @callback.
 *
 * Since: 2.22
 **/
void
g_drive_eject_with_operation (GDrive              *drive,
                              GMountUnmountFlags   flags,
                              GMountOperation     *mount_operation,
                              GCancellable        *cancellable,
                              GAsyncReadyCallback  callback,
                              gpointer             user_data)
{
  GDriveIface *iface;

  g_return_if_fail (G_IS_DRIVE (drive));

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->eject == NULL && iface->eject_with_operation == NULL)
    {
489 490 491 492 493 494
      g_task_report_new_error (drive, callback, user_data,
                               g_drive_eject_with_operation,
                               G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                               /* Translators: This is an error
                                * message for drive objects that
                                * don't implement any of eject or eject_with_operation. */
495
                               _("drive doesn’t implement eject or eject_with_operation"));
496 497 498 499 500 501 502 503 504 505 506 507 508
      return;
    }

  if (iface->eject_with_operation != NULL)
    (* iface->eject_with_operation) (drive, flags, mount_operation, cancellable, callback, user_data);
  else
    (* iface->eject) (drive, flags, cancellable, callback, user_data);
}

/**
 * g_drive_eject_with_operation_finish:
 * @drive: a #GDrive.
 * @result: a #GAsyncResult.
Matthias Clasen's avatar
Matthias Clasen committed
509
 * @error: a #GError location to store the error occurring, or %NULL to
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
 *     ignore.
 *
 * Finishes ejecting a drive. If any errors occurred during the operation,
 * @error will be set to contain the errors and %FALSE will be returned.
 *
 * Returns: %TRUE if the drive was successfully ejected. %FALSE otherwise.
 *
 * Since: 2.22
 **/
gboolean
g_drive_eject_with_operation_finish (GDrive        *drive,
                                     GAsyncResult  *result,
                                     GError       **error)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);
  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);

529 530
  if (g_async_result_legacy_propagate_error (result, error))
    return FALSE;
531 532
  else if (g_async_result_is_tagged (result, g_drive_eject_with_operation))
    return g_task_propagate_boolean (G_TASK (result), error);
533 534 535 536 537 538 539 540

  iface = G_DRIVE_GET_IFACE (drive);
  if (iface->eject_with_operation_finish != NULL)
    return (* iface->eject_with_operation_finish) (drive, result, error);
  else
    return (* iface->eject_finish) (drive, result, error);
}

541
/**
542
 * g_drive_poll_for_media:
543
 * @drive: a #GDrive.
544 545
 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
 * @callback: (nullable): a #GAsyncReadyCallback, or %NULL.
Matthias Clasen's avatar
Matthias Clasen committed
546
 * @user_data: user data to pass to @callback
547
 * 
Matthias Clasen's avatar
Matthias Clasen committed
548
 * Asynchronously polls @drive to see if media has been inserted or removed.
549
 * 
Matthias Clasen's avatar
Matthias Clasen committed
550 551 552
 * When the operation is finished, @callback will be called.
 * You can then call g_drive_poll_for_media_finish() to obtain the
 * result of the operation.
553 554
 **/
void
555 556 557 558
g_drive_poll_for_media (GDrive              *drive,
                        GCancellable        *cancellable,
                        GAsyncReadyCallback  callback,
                        gpointer             user_data)
559 560 561 562 563 564 565
{
  GDriveIface *iface;

  g_return_if_fail (G_IS_DRIVE (drive));

  iface = G_DRIVE_GET_IFACE (drive);

566
  if (iface->poll_for_media == NULL)
567
    {
568 569 570
      g_task_report_new_error (drive, callback, user_data,
                               g_drive_poll_for_media,
                               G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
571
                               _("drive doesn’t implement polling for media"));
572 573 574
      return;
    }
  
575
  (* iface->poll_for_media) (drive, cancellable, callback, user_data);
576 577 578
}

/**
Matthias Clasen's avatar
Matthias Clasen committed
579
 * g_drive_poll_for_media_finish:
580 581
 * @drive: a #GDrive.
 * @result: a #GAsyncResult.
Matthias Clasen's avatar
Matthias Clasen committed
582
 * @error: a #GError, or %NULL
583
 * 
Matthias Clasen's avatar
Matthias Clasen committed
584
 * Finishes an operation started with g_drive_poll_for_media() on a drive.
585
 * 
586
 * Returns: %TRUE if the drive has been poll_for_mediaed successfully,
Matthias Clasen's avatar
Matthias Clasen committed
587
 *     %FALSE otherwise.
588 589
 **/
gboolean
590 591 592
g_drive_poll_for_media_finish (GDrive        *drive,
                               GAsyncResult  *result,
                               GError       **error)
593 594 595 596 597 598
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);
  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);

599 600
  if (g_async_result_legacy_propagate_error (result, error))
    return FALSE;
601 602
  else if (g_async_result_is_tagged (result, g_drive_poll_for_media))
    return g_task_propagate_boolean (G_TASK (result), error);
603

604 605
  iface = G_DRIVE_GET_IFACE (drive);
  
606
  return (* iface->poll_for_media_finish) (drive, result, error);
607
}
608

Matthias Clasen's avatar
Matthias Clasen committed
609 610 611 612 613
/**
 * g_drive_get_identifier:
 * @drive: a #GDrive
 * @kind: the kind of identifier to return
 *
614 615 616
 * Gets the identifier of the given kind for @drive. The only
 * identifier currently available is
 * #G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE.
Matthias Clasen's avatar
Matthias Clasen committed
617
 *
618
 * Returns: (nullable) (transfer full): a newly allocated string containing the
619
 *     requested identifier, or %NULL if the #GDrive
Matthias Clasen's avatar
Matthias Clasen committed
620
 *     doesn't have this kind of identifier.
Matthias Clasen's avatar
Matthias Clasen committed
621
 */
622
char *
Matthias Clasen's avatar
Matthias Clasen committed
623 624
g_drive_get_identifier (GDrive     *drive,
			const char *kind)
625 626 627 628 629 630 631 632 633 634 635 636 637 638
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);
  g_return_val_if_fail (kind != NULL, NULL);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->get_identifier == NULL)
    return NULL;
  
  return (* iface->get_identifier) (drive, kind);
}

Matthias Clasen's avatar
Matthias Clasen committed
639 640 641 642 643
/**
 * g_drive_enumerate_identifiers:
 * @drive: a #GDrive
 *
 * Gets the kinds of identifiers that @drive has. 
644
 * Use g_drive_get_identifier() to obtain the identifiers
Matthias Clasen's avatar
Matthias Clasen committed
645 646
 * themselves.
 *
647 648 649
 * Returns: (transfer full) (array zero-terminated=1): a %NULL-terminated
 *     array of strings containing kinds of identifiers. Use g_strfreev()
 *     to free.
Matthias Clasen's avatar
Matthias Clasen committed
650
 */
651 652 653 654 655 656 657 658 659 660 661 662 663 664
char **
g_drive_enumerate_identifiers (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);
  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->enumerate_identifiers == NULL)
    return NULL;
  
  return (* iface->enumerate_identifiers) (drive);
}

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 706 707 708 709 710 711 712 713 714 715
/**
 * g_drive_get_start_stop_type:
 * @drive: a #GDrive.
 *
 * Gets a hint about how a drive can be started/stopped.
 *
 * Returns: A value from the #GDriveStartStopType enumeration.
 *
 * Since: 2.22
 */
GDriveStartStopType
g_drive_get_start_stop_type (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->get_start_stop_type == NULL)
    return G_DRIVE_START_STOP_TYPE_UNKNOWN;

  return (* iface->get_start_stop_type) (drive);
}


/**
 * g_drive_can_start:
 * @drive: a #GDrive.
 *
 * Checks if a drive can be started.
 *
 * Returns: %TRUE if the @drive can be started, %FALSE otherwise.
 *
 * Since: 2.22
 */
gboolean
g_drive_can_start (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->can_start == NULL)
    return FALSE;

  return (* iface->can_start) (drive);
}

716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
/**
 * g_drive_can_start_degraded:
 * @drive: a #GDrive.
 *
 * Checks if a drive can be started degraded.
 *
 * Returns: %TRUE if the @drive can be started degraded, %FALSE otherwise.
 *
 * Since: 2.22
 */
gboolean
g_drive_can_start_degraded (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->can_start_degraded == NULL)
    return FALSE;

  return (* iface->can_start_degraded) (drive);
}

741 742 743 744
/**
 * g_drive_start:
 * @drive: a #GDrive.
 * @flags: flags affecting the start operation.
745
 * @mount_operation: (nullable): a #GMountOperation or %NULL to avoid
746
 *     user interaction.
747 748
 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
 * @callback: (nullable): a #GAsyncReadyCallback, or %NULL.
749 750 751 752 753 754 755 756 757 758 759 760 761
 * @user_data: user data to pass to @callback
 *
 * Asynchronously starts a drive.
 *
 * When the operation is finished, @callback will be called.
 * You can then call g_drive_start_finish() to obtain the
 * result of the operation.
 *
 * Since: 2.22
 */
void
g_drive_start (GDrive              *drive,
               GDriveStartFlags     flags,
762
               GMountOperation     *mount_operation,
763 764 765 766 767 768 769 770 771 772 773 774
               GCancellable        *cancellable,
               GAsyncReadyCallback  callback,
               gpointer             user_data)
{
  GDriveIface *iface;

  g_return_if_fail (G_IS_DRIVE (drive));

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->start == NULL)
    {
775 776 777
      g_task_report_new_error (drive, callback, user_data,
                               g_drive_start,
                               G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
778
                               _("drive doesn’t implement start"));
779 780 781
      return;
    }

782
  (* iface->start) (drive, flags, mount_operation, cancellable, callback, user_data);
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807
}

/**
 * g_drive_start_finish:
 * @drive: a #GDrive.
 * @result: a #GAsyncResult.
 * @error: a #GError, or %NULL
 *
 * Finishes starting a drive.
 *
 * Returns: %TRUE if the drive has been started successfully,
 *     %FALSE otherwise.
 *
 * Since: 2.22
 */
gboolean
g_drive_start_finish (GDrive         *drive,
                      GAsyncResult   *result,
                      GError        **error)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);
  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);

808 809
  if (g_async_result_legacy_propagate_error (result, error))
    return FALSE;
810 811
  else if (g_async_result_is_tagged (result, g_drive_start))
    return g_task_propagate_boolean (G_TASK (result), error);
812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->start_finish) (drive, result, error);
}

/**
 * g_drive_can_stop:
 * @drive: a #GDrive.
 *
 * Checks if a drive can be stopped.
 *
 * Returns: %TRUE if the @drive can be stopped, %FALSE otherwise.
 *
 * Since: 2.22
 */
gboolean
g_drive_can_stop (GDrive *drive)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->can_stop == NULL)
    return FALSE;

  return (* iface->can_stop) (drive);
}

/**
 * g_drive_stop:
 * @drive: a #GDrive.
 * @flags: flags affecting the unmount if required for stopping.
847
 * @mount_operation: (nullable): a #GMountOperation or %NULL to avoid
848
 *     user interaction.
849 850
 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
 * @callback: (nullable): a #GAsyncReadyCallback, or %NULL.
851 852 853 854 855 856 857 858 859 860 861 862 863
 * @user_data: user data to pass to @callback
 *
 * Asynchronously stops a drive.
 *
 * When the operation is finished, @callback will be called.
 * You can then call g_drive_stop_finish() to obtain the
 * result of the operation.
 *
 * Since: 2.22
 */
void
g_drive_stop (GDrive               *drive,
              GMountUnmountFlags    flags,
864
              GMountOperation      *mount_operation,
865 866 867 868 869 870 871 872 873 874 875 876
              GCancellable         *cancellable,
              GAsyncReadyCallback   callback,
              gpointer              user_data)
{
  GDriveIface *iface;

  g_return_if_fail (G_IS_DRIVE (drive));

  iface = G_DRIVE_GET_IFACE (drive);

  if (iface->stop == NULL)
    {
877 878 879
      g_task_report_new_error (drive, callback, user_data,
                               g_drive_start,
                               G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
880
                               _("drive doesn’t implement stop"));
881 882 883
      return;
    }

884
  (* iface->stop) (drive, flags, mount_operation, cancellable, callback, user_data);
885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909
}

/**
 * g_drive_stop_finish:
 * @drive: a #GDrive.
 * @result: a #GAsyncResult.
 * @error: a #GError, or %NULL
 *
 * Finishes stopping a drive.
 *
 * Returns: %TRUE if the drive has been stopped successfully,
 *     %FALSE otherwise.
 *
 * Since: 2.22
 */
gboolean
g_drive_stop_finish (GDrive        *drive,
                     GAsyncResult  *result,
                     GError       **error)
{
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), FALSE);
  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);

910 911
  if (g_async_result_legacy_propagate_error (result, error))
    return FALSE;
912 913
  else if (g_async_result_is_tagged (result, g_drive_start))
    return g_task_propagate_boolean (G_TASK (result), error);
914 915 916 917 918

  iface = G_DRIVE_GET_IFACE (drive);

  return (* iface->stop_finish) (drive, result, error);
}
919 920 921 922 923 924 925

/**
 * g_drive_get_sort_key:
 * @drive: A #GDrive.
 *
 * Gets the sort key for @drive, if any.
 *
926
 * Returns: (nullable): Sorting key for @drive or %NULL if no such key is available.
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
 *
 * Since: 2.32
 */
const gchar *
g_drive_get_sort_key (GDrive  *drive)
{
  const gchar *ret = NULL;
  GDriveIface *iface;

  g_return_val_if_fail (G_IS_DRIVE (drive), NULL);

  iface = G_DRIVE_GET_IFACE (drive);
  if (iface->get_sort_key != NULL)
    ret = iface->get_sort_key (drive);

  return ret;
}