void DistroUpgrade::distroUpgrade(PackageKit::Transaction::DistroUpgrade type, const QString &name, const QString &description)
{
// TODO make use of the type
switch (m_configs[CFG_DISTRO_UPGRADE].toInt()) {
case Enum::DistroNever:
return;
case Enum::DistroStable:
if (type != Transaction::DistroUpgradeStable) {
// The user only wants to know about stable releases
return;
}
default:
break;
}
kDebug() << "Distro upgrade found!" << name << description;
if (m_shownDistroUpgrades.contains(name)) {
// ignore distro upgrade if the user already saw it
return;
}
KNotification *notify = new KNotification("DistroUpgradeAvailable", 0, KNotification::Persistent);
notify->setComponentName("apperd");
notify->setTitle(i18n("Distribution upgrade available"));
notify->setText(description);
QStringList actions;
actions << i18n("Start upgrade now");
notify->setActions(actions);
connect(notify, SIGNAL(activated(uint)),
this, SLOT(handleDistroUpgradeAction(uint)));
notify->sendEvent();
m_shownDistroUpgrades << name;
}
void Handler::activateConnection(const QString& connection, const QString& device, const QString& specificObject)
{
NetworkManager::Connection::Ptr con = NetworkManager::findConnection(connection);
if (!con) {
qCWarning(NM) << "Not possible to activate this connection";
return;
}
if (con->settings()->connectionType() == NetworkManager::ConnectionSettings::Vpn) {
NetworkManager::VpnSetting::Ptr vpnSetting = con->settings()->setting(NetworkManager::Setting::Vpn).staticCast<NetworkManager::VpnSetting>();
if (vpnSetting) {
// qCDebug(NM) << "Checking VPN" << con->name() << "type:" << vpnSetting->serviceType();
#if 0
// get the list of supported VPN service types
const KService::List services = KServiceTypeTrader::self()->query("PlasmaNetworkManagement/VpnUiPlugin",
QString::fromLatin1("[X-NetworkManager-Services]=='%1'").arg(vpnSetting->serviceType()));
if (services.isEmpty()) {
qCWarning(NM) << "VPN" << vpnSetting->serviceType() << "not found, skipping";
KNotification *notification = new KNotification("MissingVpnPlugin", KNotification::CloseOnTimeout, this);
notification->setComponentName("networkmanagement");
notification->setTitle(con->name());
notification->setText(i18n("Missing VPN plugin"));
notification->setPixmap(QIcon::fromTheme("dialog-warning").pixmap(KIconLoader::SizeHuge));
notification->sendEvent();
return;
}
#endif
}
}
#if WITH_MODEMMANAGER_SUPPORT
if (con->settings()->connectionType() == NetworkManager::ConnectionSettings::Gsm) {
NetworkManager::ModemDevice::Ptr nmModemDevice = NetworkManager::findNetworkInterface(device).objectCast<NetworkManager::ModemDevice>();
if (nmModemDevice) {
ModemManager::ModemDevice::Ptr mmModemDevice = ModemManager::findModemDevice(nmModemDevice->udi());
if (mmModemDevice) {
ModemManager::Modem::Ptr modem = mmModemDevice->interface(ModemManager::ModemDevice::ModemInterface).objectCast<ModemManager::Modem>();
NetworkManager::GsmSetting::Ptr gsmSetting = con->settings()->setting(NetworkManager::Setting::Gsm).staticCast<NetworkManager::GsmSetting>();
if (gsmSetting && gsmSetting->pinFlags() == NetworkManager::Setting::NotSaved &&
modem && modem->unlockRequired() > MM_MODEM_LOCK_NONE) {
QDBusInterface managerIface("org.kde.plasmanetworkmanagement", "/org/kde/plasmanetworkmanagement", "org.kde.plasmanetworkmanagement", QDBusConnection::sessionBus(), this);
managerIface.call("unlockModem", mmModemDevice->uni());
connect(modem.data(), &ModemManager::Modem::unlockRequiredChanged, this, &Handler::unlockRequiredChanged);
m_tmpConnectionPath = connection;
m_tmpDevicePath = device;
m_tmpSpecificPath = specificObject;
return;
}
}
}
}
#endif
QDBusPendingReply<QDBusObjectPath> reply = NetworkManager::activateConnection(connection, device, specificObject);
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this);
watcher->setProperty("action", Handler::ActivateConnection);
watcher->setProperty("connection", con->name());
connect(watcher, &QDBusPendingCallWatcher::finished, this, &Handler::replyFinished);
}
void Notify::connectionFailed(const QString &title, BluezQt::PendingCall *call)
{
QString text;
switch (call->error()) {
case BluezQt::PendingCall::Failed:
if (call->errorText() == QLatin1String("Host is down")) {
text = i18nc("Notification when the connection failed due to Failed:HostIsDown",
"The device is unreachable");
} else {
text = i18nc("Notification when the connection failed due to Failed",
"Connection to the device failed");
}
break;
case BluezQt::PendingCall::NotReady:
text = i18nc("Notification when the connection failed due to NotReady",
"The device is not ready");
break;
default:
return;
}
KNotification *notification = new KNotification(QStringLiteral("ConnectionFailed"),
KNotification::CloseOnTimeout, this);
notification->setComponentName(QStringLiteral("bluedevil"));
notification->setPixmap(QIcon::fromTheme(QStringLiteral("dialog-warning")).pixmap(64));
notification->setTitle(title);
notification->setText(text);
notification->sendEvent();
}
// to avoid additional object definition this method is static
void AWActions::sendNotification(const QString eventId, const QString message)
{
qCDebug(LOG_AW) << "Event" << eventId << "with message" << message;
KNotification *notification = KNotification::event(
eventId, QString("Awesome Widget ::: %1").arg(eventId), message);
notification->setComponentName(
QString("plasma-applet-org.kde.plasma.awesome-widget"));
}
KNotification *KNotification::event(const QString &eventid, const QString &title, const QString &text,
const QPixmap &pixmap, QWidget *widget, const NotificationFlags &flags, const QString &componentName)
{
KNotification *notify = new KNotification(eventid, widget, flags);
notify->setTitle(title);
notify->setText(text);
notify->setPixmap(pixmap);
notify->setComponentName(flags & DefaultEvent ? QStringLiteral("plasma_workspace") : componentName);
QTimer::singleShot(0, notify, SLOT(sendEvent()));
return notify;
}
void DistroUpgrade::distroUpgradeFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
KNotification *notify = new KNotification("DistroUpgradeFinished");
notify->setComponentName("apperd");
if (exitStatus == QProcess::NormalExit && exitCode == 0) {
notify->setPixmap(KIcon("security-high").pixmap(64, 64));
notify->setText(i18n("Distribution upgrade finished. "));
} else if (exitStatus == QProcess::NormalExit) {
notify->setPixmap(KIcon("dialog-warning").pixmap(64, 64));
notify->setText(i18n("Distribution upgrade process exited with code %1.", exitCode));
}/* else {
notify->setText(i18n("Distribution upgrade didn't exit normally, the process probably crashed. "));
}*/
notify->sendEvent();
m_distroUpgradeProcess->deleteLater();
m_distroUpgradeProcess = 0;
// suppressSleep(false);
}
void DistroUpgrade::distroUpgradeError(QProcess::ProcessError error)
{
QString text;
KNotification *notify = new KNotification("DistroUpgradeError");
notify->setComponentName("apperd");
switch(error) {
case QProcess::FailedToStart:
text = i18n("The distribution upgrade process failed to start.");
break;
case QProcess::Crashed:
text = i18n("The distribution upgrade process crashed some time after starting successfully.") ;
break;
default:
text = i18n("The distribution upgrade process failed with an unknown error.");
break;
}
notify->setPixmap(KIcon("dialog-error").pixmap(64,64));
notify->setText(text);
notify->sendEvent();
}
void AdiumxtraProtocolHandler::install()
{
if (m_url.isEmpty()) {
Q_EMIT finished();
return; // BundleInstaller:: xxxxx
}
QUrl url = QUrl::fromUserInput(m_url);
if(url.scheme() == QLatin1String("adiumxtra")) {
url.setScheme(QStringLiteral("http"));
}
QTemporaryFile *tmpFile = new QTemporaryFile();
if (tmpFile->open()) {
KIO::Job* getJob = KIO::file_copy(url, QUrl::fromLocalFile(tmpFile->fileName()), -1,
KIO::Overwrite | KIO::HideProgressInfo);
if (getJob->exec()) {
qWarning() << "Download failed";
Q_EMIT finished();
return; // BundleInstaller::BundleCannotOpen;
}
getJob->deleteLater();
}
KArchive *archive = 0L;
QMimeDatabase db;
QString currentBundleMimeType = db.mimeTypeForFile(tmpFile->fileName()).name();
if (currentBundleMimeType == QLatin1String("application/zip")) {
archive = new KZip(tmpFile->fileName());
} else if (currentBundleMimeType == QLatin1String("application/x-compressed-tar") ||
currentBundleMimeType == QLatin1String("application/x-bzip-compressed-tar") ||
currentBundleMimeType == QLatin1String("application/x-gzip") ||
currentBundleMimeType == QLatin1String("application/x-bzip")) {
archive = new KTar(tmpFile->fileName());
} else {
KNotification *notification = new KNotification(QLatin1String("packagenotrecognized"), NULL, KNotification::Persistent);
notification->setText( i18n("Package type not recognized or not supported") );
notification->setActions( QStringList() << i18n("OK") );
QObject::connect(notification, SIGNAL(action1Activated()), notification, SLOT(close()));
QObject::connect(notification, SIGNAL(ignored()), notification, SLOT(close()));
notification->setComponentName(ktelepathyComponentName());
notification->sendEvent();
qWarning() << "Unsupported file type" << currentBundleMimeType;
Q_EMIT finished();
return;// BundleInstaller::BundleNotValid;
}
if (!archive->open(QIODevice::ReadOnly)) {
delete archive;
qWarning() << "Cannot open theme file";
Q_EMIT finished();
return;// BundleInstaller::BundleCannotOpen;
}
ChatStyleInstaller *chatStyleInstaller = new ChatStyleInstaller(archive, tmpFile);
if (chatStyleInstaller->validate() == BundleInstaller::BundleValid) {
chatStyleInstaller->showRequest();
QObject::connect(chatStyleInstaller, SIGNAL(finished(BundleInstaller::BundleStatus)),
chatStyleInstaller, SLOT(showResult()));
QObject::connect(chatStyleInstaller, SIGNAL(showedResult()), this, SIGNAL(finished()));
QObject::connect(chatStyleInstaller, SIGNAL(showedResult()),
chatStyleInstaller, SLOT(deleteLater()));
QObject::connect(chatStyleInstaller, SIGNAL(ignoredRequest()), this, SIGNAL(finished()));
QObject::connect(chatStyleInstaller, SIGNAL(ignoredRequest()),
chatStyleInstaller, SLOT(deleteLater()));
return;// BundleInstaller::BundleValid;
}
delete chatStyleInstaller;
EmoticonSetInstaller *emoticonSetInstaller = new EmoticonSetInstaller(archive, tmpFile);
if(emoticonSetInstaller->validate() == BundleInstaller::BundleValid) {
emoticonSetInstaller->showRequest();
QObject::connect(emoticonSetInstaller, SIGNAL(finished(BundleInstaller::BundleStatus)),
emoticonSetInstaller, SLOT(showResult()));
QObject::connect(emoticonSetInstaller, SIGNAL(showedResult()), this, SIGNAL(finished()));
QObject::connect(emoticonSetInstaller, SIGNAL(showedResult()),
emoticonSetInstaller, SLOT(deleteLater()));
QObject::connect(emoticonSetInstaller, SIGNAL(ignoredRequest()), this, SIGNAL(finished()));
QObject::connect(emoticonSetInstaller, SIGNAL(ignoredRequest()),
emoticonSetInstaller, SLOT(deleteLater()));
return;// BundleInstaller::BundleValid;
}
delete emoticonSetInstaller;
KNotification *notification = new KNotification(QLatin1String("packagenotrecognized"),
NULL,
KNotification::Persistent);
notification->setText( i18n("Package type not recognized or not supported") );
QObject::connect(notification, SIGNAL(action1Activated()), notification, SLOT(close()));
QObject::connect(notification, SIGNAL(ignored()), notification, SLOT(close()));
notification->setActions( QStringList() << i18n("OK") );
notification->setComponentName(ktelepathyComponentName());
notification->sendEvent();
Q_EMIT finished();
return;// BundleInstaller::BundleUnknownError;
}