DeviceAutomounter.cpp 5.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/***************************************************************************
*   Copyright (C) 2009 by Trever Fischer <wm161@wm161.net>                *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
*   This program 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 General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU General Public License     *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
***************************************************************************/

#include "DeviceAutomounter.h"

#include <KPluginFactory>

#include <Solid/Device>
#include <Solid/DeviceNotifier>
#include <Solid/StorageAccess>
#include <Solid/StorageVolume>

29 30 31
#include <QDBusConnection>
#include <QDBusMessage>

32 33
#include <QTimer>

34 35 36
K_PLUGIN_FACTORY_WITH_JSON(DeviceAutomounterFactory,
                           "device_automounter.json",
                           registerPlugin<DeviceAutomounter>();)
37 38 39 40 41

DeviceAutomounter::DeviceAutomounter(QObject *parent, const QVariantList &args)
    : KDEDModule(parent)
{
    Q_UNUSED(args);
42
    QTimer::singleShot(0, this, &DeviceAutomounter::init);
43 44 45 46 47 48 49 50
}

DeviceAutomounter::~DeviceAutomounter()
{
}

void DeviceAutomounter::init()
{
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
    if (!AutomounterSettings::automountEnabled()) {
        // Automounting is disabled, no point in hanging around.
        QDBusConnection dbus = QDBusConnection::sessionBus();
        QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.kde.kded5"),
                                                          QStringLiteral("/kded"),
                                                          QStringLiteral("org.kde.kded5"),
                                                          QStringLiteral("setModuleAutoloading"));
        msg.setArguments({QVariant(QStringLiteral("device_automounter")), QVariant(false)});
        dbus.call(msg, QDBus::NoBlock);

        // Unload right away
        msg = QDBusMessage::createMethodCall(QStringLiteral("org.kde.kded5"),
                                             QStringLiteral("/kded"),
                                             QStringLiteral("org.kde.kded5"),
                                             QStringLiteral("unloadModule"));
        msg.setArguments({QVariant(QStringLiteral("device_automounter"))});
        dbus.call(msg, QDBus::NoBlock);
        return;
    }

71
    connect(Solid::DeviceNotifier::instance(), &Solid::DeviceNotifier::deviceAdded, this, &DeviceAutomounter::deviceAdded);
72 73
    const QList<Solid::Device> volumes = Solid::Device::listFromType(Solid::DeviceInterface::StorageVolume);
    for (Solid::Device volume : volumes) {
74
        // sa can be 0 (e.g. for the swap partition)
75
        if (const Solid::StorageAccess *sa = volume.as<Solid::StorageAccess>()) {
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
            connect(sa, &Solid::StorageAccess::accessibilityChanged, this, &DeviceAutomounter::deviceMountChanged);
        }
        automountDevice(volume, AutomounterSettings::Login);
    }
    AutomounterSettings::self()->save();
}

void DeviceAutomounter::deviceMountChanged(bool accessible, const QString &udi)
{
    AutomounterSettings::setDeviceLastSeenMounted(udi, accessible);
    AutomounterSettings::self()->save();
}

void DeviceAutomounter::automountDevice(Solid::Device &dev, AutomounterSettings::AutomountType type)
{
    if (dev.is<Solid::StorageVolume>() && dev.is<Solid::StorageAccess>()) {
        Solid::StorageAccess *sa = dev.as<Solid::StorageAccess>();

        AutomounterSettings::setDeviceLastSeenMounted(dev.udi(), sa->isAccessible());
        AutomounterSettings::saveDevice(dev);

        if (AutomounterSettings::shouldAutomountDevice(dev.udi(), type)) {
            Solid::StorageVolume *sv = dev.as<Solid::StorageVolume>();
99
            if (!sa->isAccessible() && !sv->isIgnored()) {
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
                sa->setup();
            }
        }
    }
}

void DeviceAutomounter::deviceAdded(const QString &udi)
{
    AutomounterSettings::self()->load();

    Solid::Device dev(udi);
    automountDevice(dev, AutomounterSettings::Attach);
    AutomounterSettings::self()->save();

    if (dev.is<Solid::StorageAccess>()) {
        Solid::StorageAccess *sa = dev.as<Solid::StorageAccess>();
        if (sa) {
            connect(sa, &Solid::StorageAccess::accessibilityChanged, this, &DeviceAutomounter::deviceMountChanged);
        }
    }
}

#include "DeviceAutomounter.moc"