File indexing completed on 2024-05-12 04:01:52

 /*
     SPDX-FileCopyrightText: 2006-2007 Kevin Ottens <ervin@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #ifndef SOLID_STORAGEACCESS_H
 #define SOLID_STORAGEACCESS_H
 
 #include <solid/solid_export.h>
 
 #include <QVariant>
 #include <solid/deviceinterface.h>
 #include <solid/solidnamespace.h>
 
 namespace Solid
 {
 class StorageAccessPrivate;
 class Device;
 
 /**
  * @class Solid::StorageAccess storageaccess.h <Solid/StorageAccess>
  *
  * This device interface is available on volume devices to access them
  * (i.e. mount or unmount them).
  *
  * A volume is anything that can contain data (partition, optical disc,
  * memory card). It's a particular kind of block device.
  */
 class SOLID_EXPORT StorageAccess : public DeviceInterface
 {
     Q_OBJECT
     Q_PROPERTY(bool accessible READ isAccessible)
     Q_PROPERTY(QString filePath READ filePath)
     Q_PROPERTY(bool ignored READ isIgnored)
     Q_PROPERTY(bool encrypted READ isEncrypted)
     Q_DECLARE_PRIVATE(StorageAccess)
     friend class Device;
 
 private:
     /**
      * Creates a new StorageAccess object.
      * You generally won't need this. It's created when necessary using
      * Device::as().
      *
      * @param backendObject the device interface object provided by the backend
      * @see Solid::Device::as()
      */
     SOLID_NO_EXPORT explicit StorageAccess(QObject *backendObject);
 
 public:
     /**
      * Destroys a StorageAccess object.
      */
     ~StorageAccess() override;
 
     /**
      * Get the Solid::DeviceInterface::Type of the StorageAccess device interface.
      *
      * @return the StorageVolume device interface type
      * @see Solid::Ifaces::Enums::DeviceInterface::Type
      */
     static Type deviceInterfaceType()
     {
         return DeviceInterface::StorageAccess;
     }
 
     /**
      * Indicates if this volume is mounted.
      *
      * @return true if the volume is mounted
      */
     bool isAccessible() const;
 
     /**
      * Retrieves the absolute path of this volume mountpoint.
      *
      * @return the absolute path to the mount point if the volume is
      * mounted, QString() otherwise
      */
     QString filePath() const;
 
     /**
      * Indicates if this volume should be ignored by applications.
      *
      * If it should be ignored, it generally means that it should be
      * invisible to the user. It's useful for firmware partitions or
      * OS reinstall partitions on some systems.
      *
      * @return true if the volume should be ignored
      */
     bool isIgnored() const;
 
     /**
      * Checks if source of the storage is encrypted.
      *
      * @return true if storage is encrypted one
      *
      * @since 5.80
      */
     bool isEncrypted() const;
 
     /**
      * Mounts the volume.
      *
      * @return false if the operation is not supported, true if the
      * operation is attempted
      */
     bool setup();
 
     /**
      * Unmounts the volume.
      *
      * @return false if the operation is not supported, true if the
      * operation is attempted
      */
     bool teardown();
 
 Q_SIGNALS:
     /**
      * This signal is emitted when the accessiblity of this device
      * has changed.
      *
      * @param accessible true if the volume is accessible, false otherwise
      * @param udi the UDI of the volume
      */
     void accessibilityChanged(bool accessible, const QString &udi);
 
     /**
      * This signal is emitted when the attempted setting up of this
      * device is completed. The signal might be spontaneous i.e.
      * it can be triggered by another process.
      *
      * @param error type of error that occurred, if any
      * @param errorData more information about the error, if any
      * @param udi the UDI of the volume
      */
     void setupDone(Solid::ErrorType error, QVariant errorData, const QString &udi);
 
     /**
      * This signal is emitted when the attempted tearing down of this
      * device is completed. The signal might be spontaneous i.e.
      * it can be triggered by another process.
      *
      * @param error type of error that occurred, if any
      * @param errorData more information about the error, if any
      * @param udi the UDI of the volume
      */
     void teardownDone(Solid::ErrorType error, QVariant errorData, const QString &udi);
 
     /**
      * This signal is emitted when a setup of this device is requested.
      * The signal might be spontaneous i.e. it can be triggered by
      * another process.
      *
      * @param udi the UDI of the volume
      */
     void setupRequested(const QString &udi);
 
     /**
      * This signal is emitted when a teardown of this device is requested.
      * The signal might be spontaneous i.e. it can be triggered by
      * another process
      *
      * @param udi the UDI of the volume
      */
     void teardownRequested(const QString &udi);
 
 protected:
     /**
      * @internal
      */
     SOLID_NO_EXPORT StorageAccess(StorageAccessPrivate &dd, QObject *backendObject);
 };
 }
 
 #endif