blumia/dde-application-manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: implementation of the major feature of dbus service

Browse Source 
Log:
Signed-off-by: ComixHe <heyuming@deepin.org>
This commit is contained in:
ComixHe
2023-07-24 14:12:59 +08:00
committed by Comix
parent 839383ecae
commit fe284e78b6
30 changed files with 1446 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/CMakeLists.txt
View File

@ -19,8 +19,13 @@ target_link_libraries(${LIB_NAME} PUBLIC
)
add_executable(${BIN_NAME} main.cpp utils.cpp)
target_link_libraries(${BIN_NAME} PRIVATE
${LIB_NAME}
)
target_include_directories(${BIN_NAME} PRIVATE
${PROJECT_BINARY_DIR}
)
install(TARGETS ${BIN_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR})

61
src/cgroupsidentifier.cpp Normal file
View File

@ -0,0 +1,61 @@
// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd.
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#include "cgroupsidentifier.h"
#include "global.h"
#include <QFile>
#include <QString>
#include <QDebug>
IdentifyRet CGroupsIdentifier::Identify(pid_t pid)
{
auto AppCgroupPath = QString("/proc/%1/cgroup").arg(pid);
QFile AppCgroupFile{AppCgroupPath};
if (!AppCgroupFile.open(QFile::ExistingOnly | QFile::ReadOnly | QFile::Text)) {
qWarning() << "open " << AppCgroupPath << "failed: " << AppCgroupFile.errorString();
return {};
}
auto appInstance = parseCGroupsPath(
AppCgroupFile.readAll().split(':').last().trimmed()); // FIXME: support CGroup version detection and multi-line parsing
auto appInstanceComponent = appInstance.split('@');
if (appInstanceComponent.count() != 2) {
qWarning() << "Application Instance format is invalid." << appInstanceComponent;
return {};
}
return {appInstanceComponent.first(), appInstanceComponent.last()};
}
QString CGroupsIdentifier::parseCGroupsPath(QString CGP) const noexcept
{
if (CGP.isEmpty()) {
qWarning() << "CGroupPath is empty.";
return {};
}
auto unescapedCGP = unescapeString(CGP);
auto CGPSlices = unescapedCGP.split('/');
auto curUID = getCurrentUID();
if (CGPSlices.first() != "user.slice") {
qWarning() << "unrecognized process.";
return {};
}
auto processUIDStr = CGPSlices[1].split('.').first().split('-').last();
if (processUIDStr.isEmpty()) {
qWarning() << "no uid found.";
return {};
}
if (auto processUID = processUIDStr.toInt(); processUID != getCurrentUID()) {
qWarning() << "process is not in CGroups of current user, ignore....";
return {};
}
auto appInstance = CGPSlices.last().split('.').first();
if (appInstance.isEmpty()) {
qWarning() << "get AppId failed.";
return {};
}
return appInstance;
}

103
src/dbus/applicationmanager1service.cpp
View File

@ -2,12 +2,27 @@
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#include "applicationmanager1service.h"
#include "applicationadaptor.h"
#include "global.h"
#include "applicationmanager1adaptor.h"
#include <QFile>
#include <unistd.h>
ApplicationManager1Service::~ApplicationManager1Service() = default;
ApplicationManager1Service::ApplicationManager1Service() = default;
ApplicationManager1Service::ApplicationManager1Service(std::unique_ptr<Identifier> ptr, QDBusConnection &connection)
: m_identifier(std::move(ptr))
{
if (!connection.registerService(DDEApplicationManager1ServiceName)) {
qFatal() << connection.lastError();
}
if (!registerObjectToDBus(new ApplicationManager1Adaptor{this},
DDEApplicationManager1ObjectPath,
getDBusInterface<ApplicationManager1Adaptor>())) {
std::terminate();
}
m_jobManager.reset(new JobManager1Service(this));
}
QList<QDBusObjectPath> ApplicationManager1Service::list() const
{
@ -24,9 +39,18 @@ void ApplicationManager1Service::removeAllApplication()
m_applicationList.clear();
}
QDBusObjectPath ApplicationManager1Service::Application(const QString &id)
QDBusObjectPath ApplicationManager1Service::Application(const QString &id) const
{
// TODO: impl
auto ret = std::find_if(m_applicationList.cbegin(), m_applicationList.cend(), [&id](const auto &app) {
if (app->id() == id) {
return true;
}
return false;
});
if (ret != m_applicationList.cend()) {
return ret.key();
}
return {};
}
@ -34,8 +58,52 @@ QString ApplicationManager1Service::Identify(const QDBusUnixFileDescriptor &pidf
QDBusObjectPath &application,
QDBusObjectPath &application_instance)
{
// TODO: impl
return {};
if (!pidfd.isValid()) {
qWarning() << "pidfd isn't a valid unix file descriptor";
return {};
}
Q_ASSERT_X(static_cast<bool>(m_identifier), "Identify", "Broken Identifier.");
QString fdFilePath = QString{"/proc/self/fdinfo/%1"}.arg(pidfd.fileDescriptor());
QFile fdFile{fdFilePath};
if (!fdFile.open(QFile::ExistingOnly | QFile::ReadOnly | QFile::Text)) {
qWarning() << "open " << fdFilePath << "failed: " << fdFile.errorString();
return {};
}
auto content = fdFile.readAll();
QTextStream stream{content};
QString appPid;
while (!stream.atEnd()) {
auto line = stream.readLine();
if (line.startsWith("Pid")) {
appPid = line.split(":").last().trimmed();
break;
}
}
if (appPid.isEmpty()) {
qWarning() << "can't find pid which corresponding with the instance of this application.";
return {};
}
bool ok;
auto pid = appPid.toUInt(&ok);
if (!ok) {
qWarning() << "AppId is failed to convert to uint.";
return {};
}
const auto ret = m_identifier->Identify(pid);
auto app = std::find_if(m_applicationList.cbegin(), m_applicationList.cend(), [&ret](const auto &appPtr) {
return appPtr->id() == ret.ApplicationId;
});
if (app == m_applicationList.cend()) {
qWarning() << "can't find application:" << ret.ApplicationId;
return {};
}
application = m_applicationList.key(*app);
application_instance = (*app)->findInstance(ret.InstanceId);
return ret.ApplicationId;
}
QDBusObjectPath ApplicationManager1Service::Launch(const QString &id,
@ -43,18 +111,13 @@ QDBusObjectPath ApplicationManager1Service::Launch(const QString &id,
const QStringList &fields,
const QVariantMap &options)
{
// TODO: impl reset of Launch
QString objectPath;
if (id.contains('.')) {
objectPath = id.split('.').first();
auto app = Application(id);
if (app.path().isEmpty()) {
qWarning() << "No such application.";
return {};
}
objectPath.prepend(DDEApplicationManager1ApplicationObjectPath);
QSharedPointer<ApplicationService> app{new ApplicationService{id}};
auto *ptr = app.data();
if (registerObjectToDbus(new ApplicationAdaptor(ptr), objectPath, getDBusInterface<ApplicationAdaptor>())) {
QDBusObjectPath path{objectPath};
m_applicationList.insert(path, app);
return path;
}
return {};
const auto &value = m_applicationList.value(app);
return value->Launch(actions, fields, options);
}
void ApplicationManager1Service::UpdateApplicationInfo(const QStringList &update_path) {}

30
src/dbus/applicationmanager1service.h
View File

@ -9,14 +9,19 @@
#include <QDBusObjectPath>
#include <QDBusUnixFileDescriptor>
#include <QSharedPointer>
#include <QScopedPointer>
#include <memory>
#include <QMap>
#include "jobmanager1service.h"
#include "applicationservice.h"
#include "applicationadaptor.h"
#include "identifier.h"
class ApplicationManager1Service final : public QObject
{
Q_OBJECT
public:
ApplicationManager1Service();
explicit ApplicationManager1Service(std::unique_ptr<Identifier> ptr, QDBusConnection &connection);
~ApplicationManager1Service() override;
ApplicationManager1Service(const ApplicationManager1Service &) = delete;
ApplicationManager1Service(ApplicationManager1Service &&) = delete;
@ -25,16 +30,35 @@ public:
Q_PROPERTY(QList<QDBusObjectPath> List READ list)
QList<QDBusObjectPath> list() const;
void addApplication(const QString &ID, const QStringList &actions, bool AutoStart = false);
template <typename T>
bool addApplication(T &&desktopFileSource)
{
QSharedPointer<ApplicationService> application{new ApplicationService{std::forward<T>(desktopFileSource), this}};
if (!application) {
return false;
}
if (!registerObjectToDBus(new ApplicationAdaptor{application.data()},
application->m_applicationPath.path(),
getDBusInterface<ApplicationAdaptor>())) {
return false;
}
m_applicationList.insert(application->m_applicationPath, application);
return true;
}
bool removeOneApplication(const QDBusObjectPath &application);
void removeAllApplication();
JobManager1Service &jobManager() noexcept { return *m_jobManager; }
public Q_SLOTS:
QDBusObjectPath Application(const QString &id);
QDBusObjectPath Application(const QString &id) const;
QString Identify(const QDBusUnixFileDescriptor &pidfd, QDBusObjectPath &application, QDBusObjectPath &application_instance);
QDBusObjectPath Launch(const QString &id, const QString &action, const QStringList &fields, const QVariantMap &options);
void UpdateApplicationInfo(const QStringList &update_path);
private:
std::unique_ptr<Identifier> m_identifier;
QScopedPointer<JobManager1Service> m_jobManager{nullptr};
QMap<QDBusObjectPath, QSharedPointer<ApplicationService>> m_applicationList;
};

377
src/dbus/applicationservice.cpp
View File

@ -3,61 +3,220 @@
// SPDX-License-Identifier: LGPL-3.0-or-later
#include "applicationservice.h"
#include "applicationadaptor.h"
#include "applicationmanager1service.h"
#include "instanceadaptor.h"
#include "pwd.h"
#include <QUuid>
#include <QStringList>
#include <QList>
#include <QUrl>
#include <QRegularExpression>
#include <QProcess>
#include <algorithm>
ApplicationService::ApplicationService(QString ID)
: m_AutoStart(false)
, m_ID(std::move(ID))
, m_applicationPath(DDEApplicationManager1ApplicationObjectPath + m_ID)
ApplicationService::~ApplicationService()
{
m_desktopSource.destruct(m_isPersistence);
}
ApplicationService::~ApplicationService() = default;
QString ApplicationService::GetActionName(const QString &identifier, const QStringList &env)
{
// TODO: impl
return {};
const auto &supportedActions = actions();
if (supportedActions.isEmpty()) {
return {};
}
if (auto index = supportedActions.indexOf(identifier); index == -1) {
qWarning() << "can't find " << identifier << " in supported actions List.";
return {};
}
const auto &actionHeader = QString{"%1%2"}.arg(DesktopFileActionKey, identifier);
const auto &actionName = m_entry->value(actionHeader, "Name");
if (!actionName) {
return {};
}
QString locale{""};
bool ok;
if (!env.isEmpty()) {
QString lcStr;
for (const auto &lc : env) {
if (lc.startsWith("LANG")) {
locale = lc.split('=').last();
}
if (lc.startsWith("LC_ALL")) {
locale = lc.split('=').last();
break;
}
}
}
QLocale lc = locale.isEmpty() ? getUserLocale() : QLocale{locale};
const auto &name = actionName->toLocaleString(lc, ok);
if (!ok) {
qWarning() << "convert to locale string failed, dest locale:" << lc;
return {};
}
return name;
}
QDBusObjectPath ApplicationService::Launch(const QString &action, const QStringList &fields, const QVariantMap &options)
QDBusObjectPath ApplicationService::Launch(QString action, QStringList fields, QVariantMap options)
{
// TODO: impl launch app from systemd.
QString objectPath{m_applicationPath.path() + "/" + QUuid::createUuid().toString()};
QSharedPointer<InstanceService> ins{new InstanceService{objectPath, ""}};
auto *ptr = ins.data();
if (registerObjectToDbus(new InstanceAdaptor(ptr), objectPath, getDBusInterface<InstanceAdaptor>())) {
m_Instances.insert(QDBusObjectPath{objectPath}, ins);
return QDBusObjectPath{objectPath};
QString execStr;
bool ok;
const auto &supportedActions = actions();
while (!action.isEmpty() and !supportedActions.isEmpty()) { // break trick
if (auto index = supportedActions.indexOf(action); index == -1) {
qWarning() << "can't find " << action << " in supported actions List. application will use default action to launch.";
break;
}
const auto &actionHeader = QString{"%1%2"}.arg(DesktopFileEntryKey, action);
const auto &actionExec = m_entry->value(actionHeader, "Exec");
if (!actionExec) {
break;
}
execStr = actionExec->toString(ok);
if (!ok) {
qWarning() << "exec value to string failed, try default action.";
break;
}
break;
}
return {};
if (execStr.isEmpty()) {
auto Actions = m_entry->value(DesktopFileEntryKey, "Exec");
if (!Actions) {
qWarning() << "application has isn't executable.";
return {};
}
execStr = Actions->toString(ok);
if (!ok) {
qWarning() << "default action value to string failed. abort...";
return {};
}
}
auto [bin, cmds, res] = unescapeExec(execStr, fields);
uid_t uid;
auto it = options.find("uid");
if (it != options.cend()) {
uid = it->toUInt(&ok);
if (!ok) {
qWarning() << "convert uid string to uint failed: " << *it;
return {};
}
if (uid != getCurrentUID()) {
cmds.prepend(userNameLookup(uid));
cmds.prepend("--user");
cmds.prepend("pkexec");
}
} else {
uid = getCurrentUID();
}
cmds.prepend("--");
auto &jobManager = m_parent->jobManager();
return jobManager.addJob(
m_applicationPath.path(),
[this, binary = std::move(bin), commands = std::move(cmds)](QVariant variantValue) mutable -> QVariant {
auto resourceFile = variantValue.toString();
if (resourceFile.isEmpty()) {
auto instanceRandomUUID = QUuid::createUuid().toString(QUuid::Id128);
commands.push_front(QString{R"(--unitName=DDE-%1@%2.service)"}.arg(
this->id(), instanceRandomUUID)); // launcher should use this instanceId
QProcess process;
process.start(m_launcher, commands);
process.waitForFinished();
if (auto code = process.exitCode(); code != 0) {
qWarning() << "Launch Application Failed. exitCode:" << code;
return false;
}
return addOneInstance(instanceRandomUUID, m_applicationPath.path()); // TODO: pass correct Systemd Unit Path
}
int location{0};
location = commands.indexOf(R"(%f)");
if (location != -1) { // due to std::move, there only remove once
commands.remove(location);
}
auto url = QUrl::fromUserInput(resourceFile);
if (!url.isValid()) { // if url is invalid, passing to launcher directly
auto scheme = url.scheme();
if (!scheme.isEmpty()) {
// TODO: resourceFile = processRemoteFile(resourceFile);
}
}
// resourceFile must be available in the following contexts
auto tmp = commands;
tmp.insert(location, resourceFile);
auto instanceRandomUUID = QUuid::createUuid().toString(QUuid::Id128);
tmp.push_front(QString{R"(--unitName=DDE-%1@%2.service)"}.arg(this->id(), instanceRandomUUID));
QProcess process;
process.start(ApplicationLauncherBinary, tmp);
process.waitForFinished();
auto exitCode = process.exitCode();
if (exitCode != 0) {
qWarning() << "Launch Application Failed:" << binary << tmp;
}
return addOneInstance(instanceRandomUUID, m_applicationPath.path());
},
std::move(res));
}
QStringList ApplicationService::actions() const noexcept
{
return m_actions;
if (m_entry.isNull()) {
qWarning() << "desktop entry is empty, isPersistence:" << m_isPersistence;
return {};
}
const auto &actions = m_entry->value(DesktopFileEntryKey, "Actions");
if (!actions) {
return {};
}
bool ok{false};
const auto &str = actions->toString(ok);
if (!ok) {
qWarning() << "Actions convert to String failed.";
return {};
}
auto actionList = str.split(";");
actionList.removeAll("");
return actionList;
}
QStringList &ApplicationService::actionsRef() noexcept
QString ApplicationService::id() const noexcept
{
return m_actions;
}
QString ApplicationService::iD() const noexcept
{
return m_ID;
if (m_isPersistence) {
return m_desktopSource.m_file.desktopId();
}
return {};
}
IconMap ApplicationService::icons() const
{
return m_Icons;
if (m_Icons) {
return m_Icons->icons();
}
return {};
}
IconMap &ApplicationService::iconsRef()
{
return m_Icons;
return m_Icons->iconsRef();
}
bool ApplicationService::isAutoStart() const noexcept
@ -75,12 +234,168 @@ QList<QDBusObjectPath> ApplicationService::instances() const noexcept
return m_Instances.keys();
}
bool ApplicationService::removeOneInstance(const QDBusObjectPath &instance)
bool ApplicationService::addOneInstance(const QString &instanceId, const QString &application, const QString &systemdUnitPath)
{
return m_Instances.remove(instance) != 0;
auto service = new InstanceService{instanceId, application, systemdUnitPath};
auto adaptor = new InstanceAdaptor(service);
QString objectPath{DDEApplicationManager1InstanceObjectPath + instanceId};
if (registerObjectToDBus(adaptor, objectPath, getDBusInterface<InstanceAdaptor>())) {
m_Instances.insert(QDBusObjectPath{objectPath}, QSharedPointer<InstanceService>{service});
service->moveToThread(this->thread());
adaptor->moveToThread(this->thread());
return true;
}
adaptor->deleteLater();
service->deleteLater();
return false;
}
void ApplicationService::removeOneInstance(const QDBusObjectPath &instance)
{
m_Instances.remove(instance);
unregisterObjectFromDBus(instance.path());
}
void ApplicationService::removeAllInstance()
{
m_Instances.clear();
for (const auto &instance : m_Instances.keys()) {
removeOneInstance(instance);
}
}
QDBusObjectPath ApplicationService::findInstance(const QString &instanceId) const
{
for (const auto &[path, ptr] : m_Instances.asKeyValueRange()) {
if (ptr->instanceId() == instanceId) {
return path;
}
}
return {};
}
QString ApplicationService::userNameLookup(uid_t uid)
{
auto pws = getpwuid(uid);
return pws->pw_name;
}
LaunchTask ApplicationService::unescapeExec(const QString &str, const QStringList &fields)
{
LaunchTask task;
QStringList execList = str.split(' ');
task.LaunchBin = execList.first();
QRegularExpression re{"%[fFuUickdDnNvm]"};
auto matcher = re.match(str);
if (!matcher.hasMatch()) {
task.command.append(std::move(execList));
return task;
}
auto list = matcher.capturedTexts();
if (list.count() > 1) {
qWarning() << "invalid exec format, all filed code will be ignored.";
for (const auto &code : list) {
execList.removeOne(code);
}
task.command.append(std::move(execList));
return task;
}
auto filesCode = list.first().back().toLatin1();
auto codeStr = QString(R"(%%1)").arg(filesCode);
auto location = execList.indexOf(codeStr);
switch (filesCode) {
case 'f': { // Defer to async job
task.command.append(std::move(execList));
for (auto &field : fields) {
task.Resources.emplace_back(std::move(field));
}
break;
}
case 'u': {
execList.removeAt(location);
if (fields.count() > 1) {
qDebug() << R"(fields count is greater than one, %u will only take first element.)";
}
execList.insert(location, fields.first());
task.command.append(execList);
break;
}
case 'F':
[[fallthrough]];
case 'U': {
execList.removeAt(location);
auto it = execList.begin() + location;
for (const auto &field : fields) {
it = execList.insert(it, field);
}
task.command.append(std::move(execList));
break;
}
case 'i': {
execList.removeAt(location);
auto val = m_entry->value(DesktopFileEntryKey, "Icon");
if (!val) {
qDebug() << R"(Application Icons can't be found. %i will be ignored.)";
task.command.append(std::move(execList));
return task;
}
bool ok;
auto iconStr = val->toIconString(ok);
if (!ok) {
qDebug() << R"(Icons Convert to string failed. %i will be ignored.)";
task.command.append(std::move(execList));
return task;
}
auto it = execList.insert(location, iconStr);
execList.insert(it, "--icon");
task.command.append(std::move(execList));
break;
}
case 'c': {
execList.removeAt(location);
auto val = m_entry->value(DesktopFileEntryKey, "Name");
if (!val) {
qDebug() << R"(Application Name can't be found. %c will be ignored.)";
task.command.append(std::move(execList));
return task;
}
bool ok;
auto NameStr = val->toLocaleString(getUserLocale(), ok);
if (!ok) {
qDebug() << R"(Name Convert to locale string failed. %c will be ignored.)";
task.command.append(std::move(execList));
return task;
}
execList.insert(location, NameStr);
task.command.append(std::move(execList));
break;
}
case 'k': { // ignore all desktop file location for now.
execList.removeAt(location);
task.command.append(std::move(execList));
break;
}
case 'd':
case 'D':
case 'n':
case 'N':
case 'v':
[[fallthrough]]; // Deprecated field codes should be removed from the command line and ignored.
case 'm': {
execList.removeAt(location);
task.command.append(std::move(execList));
break;
}
}
if (task.Resources.isEmpty()) {
task.Resources.emplace_back(QString{""}); // mapReduce should run once at least
}
return task;
}

95
src/dbus/applicationservice.h
View File

@ -11,8 +11,14 @@
#include <QString>
#include <QDBusUnixFileDescriptor>
#include <QSharedPointer>
#include <QUuid>
#include <QTextStream>
#include <QFile>
#include "instanceservice.h"
#include "global.h"
#include "desktopentry.h"
#include "desktopicons.h"
#include "jobmanager1service.h"
class ApplicationService : public QObject
{
@ -26,10 +32,9 @@ public:
Q_PROPERTY(QStringList Actions READ actions CONSTANT)
QStringList actions() const noexcept;
QStringList &actionsRef() noexcept;
Q_PROPERTY(QString ID READ iD CONSTANT)
QString iD() const noexcept;
Q_PROPERTY(QString ID READ id CONSTANT)
QString id() const noexcept;
Q_PROPERTY(IconMap Icons READ icons)
IconMap icons() const;
@ -42,23 +47,93 @@ public:
Q_PROPERTY(QList<QDBusObjectPath> Instances READ instances)
QList<QDBusObjectPath> instances() const noexcept;
QDBusObjectPath findInstance(const QString &instanceId) const;
const QString &getLauncher() const noexcept { return m_launcher; }
void setLauncher(const QString &launcher) noexcept { m_launcher = launcher; }
bool addOneInstance(const QString &instanceId, const QString &application, const QString &systemdUnitPath = "/");
void recoverInstances(const QList<QDBusObjectPath>) noexcept;
bool removeOneInstance(const QDBusObjectPath &instance);
void removeOneInstance(const QDBusObjectPath &instance); // TODO: remove instance when app closed
void removeAllInstance();
public Q_SLOTS:
QString GetActionName(const QString &identifier, const QStringList &env);
QDBusObjectPath Launch(const QString &action, const QStringList &fields, const QVariantMap &options);
QDBusObjectPath Launch(QString action, QStringList fields, QVariantMap options);
private:
friend class ApplicationManager1Service;
explicit ApplicationService(QString ID);
bool m_AutoStart;
QString m_ID;
template <typename T>
ApplicationService(T &&source, ApplicationManager1Service *parent)
: m_parent(parent)
, m_desktopSource(std::forward<T>(source))
{
static_assert(std::is_same_v<T, DesktopFile> or std::is_same_v<T, QString>, "param type must be QString or DesktopFile.");
QString objectPath{DDEApplicationManager1ApplicationObjectPath};
QTextStream sourceStream;
QFile sourceFile;
auto dbusAppid = m_desktopSource.m_file.desktopId();
if constexpr (std::is_same_v<T, DesktopFile>) {
m_applicationPath = QDBusObjectPath{objectPath + escapeToObjectPath(dbusAppid)};
m_isPersistence = true;
sourceFile.setFileName(m_desktopSource.m_file.filePath());
if (!sourceFile.open(QFile::ExistingOnly | QFile::ReadOnly | QFile::Text)) {
qCritical() << "desktop file can't open:" << m_desktopSource.m_file.filePath() << sourceFile.errorString();
return;
}
sourceStream.setDevice(&sourceFile);
} else if (std::is_same_v<T, QString>) {
m_applicationPath = QDBusObjectPath{objectPath + QUuid::createUuid().toString(QUuid::Id128)};
m_isPersistence = false;
sourceStream.setString(&m_desktopSource.m_temp, QTextStream::ReadOnly | QTextStream::Text);
}
m_entry.reset(new DesktopEntry());
if (auto error = m_entry->parse(sourceStream); error != ParseError::NoError) {
if (error != ParseError::EntryKeyInvalid) {
m_entry.reset(nullptr);
return;
}
}
// TODO: icon lookup
}
bool m_AutoStart{false};
bool m_isPersistence;
ApplicationManager1Service *m_parent{nullptr};
QDBusObjectPath m_applicationPath;
QStringList m_actions;
QString m_launcher{ApplicationLauncherBinary};
union DesktopSource
{
template <typename T, std::enable_if_t<std::is_same_v<T, DesktopFile>, bool> = true>
DesktopSource(T &&source)
: m_file(std::forward<T>(source))
{
}
template <typename T, std::enable_if_t<std::is_same_v<T, QString>, bool> = true>
DesktopSource(T &&source)
: m_temp(std::forward<T>(source))
{
}
void destruct(bool isPersistence)
{
if (isPersistence) {
m_file.~DesktopFile();
} else {
m_temp.~QString();
}
}
~DesktopSource(){};
QString m_temp;
DesktopFile m_file;
} m_desktopSource;
QSharedPointer<DesktopEntry> m_entry{nullptr};
QSharedPointer<DesktopIcons> m_Icons{nullptr};
QMap<QDBusObjectPath, QSharedPointer<InstanceService>> m_Instances;
IconMap m_Icons;
QString userNameLookup(uid_t uid);
[[nodiscard]] LaunchTask unescapeExec(const QString &str, const QStringList &fields);
};
#endif

5
src/dbus/instanceservice.cpp
View File

@ -4,8 +4,9 @@
#include "instanceservice.h"
InstanceService::InstanceService(QString application, QString systemdUnitPath)
: m_Application(std::move(application))
InstanceService::InstanceService(QString instanceId, QString application, QString systemdUnitPath)
: m_instanceId(std::move(instanceId))
, m_Application(std::move(application))
, m_SystemdUnitPath(std::move(systemdUnitPath))
{
}

9
src/dbus/instanceservice.h
View File

@ -18,15 +18,18 @@ public:
InstanceService &operator=(const InstanceService &) = delete;
InstanceService &operator=(InstanceService &&) = delete;
Q_PROPERTY(QDBusObjectPath Application READ application CONSTANT)
Q_PROPERTY(QDBusObjectPath Application READ application)
QDBusObjectPath application() const;
Q_PROPERTY(QDBusObjectPath SystemdUnitPath READ systemdUnitPath CONSTANT)
Q_PROPERTY(QDBusObjectPath SystemdUnitPath READ systemdUnitPath)
QDBusObjectPath systemdUnitPath() const;
const QString &instanceId() const noexcept { return m_instanceId; }
private:
friend class ApplicationService;
InstanceService(QString application, QString systemdUnitPath);
InstanceService(QString instanceId, QString application, QString systemdUnitPath);
QString m_instanceId;
const QDBusObjectPath m_Application;
const QDBusObjectPath m_SystemdUnitPath;
};

33
src/dbus/jobmanager1service.cpp
View File

@ -3,7 +3,38 @@
// SPDX-License-Identifier: LGPL-3.0-or-later
#include "jobmanager1service.h"
#include "jobmanager1adaptor.h"
JobManager1Service::JobManager1Service() = default;
LaunchTask::LaunchTask()
{
qRegisterMetaType<LaunchTask>();
}
JobManager1Service::JobManager1Service(ApplicationManager1Service *parent)
: m_parent(parent)
{
if (!registerObjectToDBus(
new JobManager1Adaptor{this}, DDEApplicationManager1JobManagerObjectPath, getDBusInterface<JobManager1Adaptor>())) {
std::terminate();
}
}
JobManager1Service::~JobManager1Service() = default;
bool JobManager1Service::removeOneJob(const QDBusObjectPath &path)
{
decltype(m_jobs)::size_type removeCount{0};
{
QMutexLocker locker{&m_mutex};
removeCount = m_jobs.remove(path);
}
// removeCount means m_jobs can't find value which corresponding with path
// and we shouldn't emit jobRemoved signal because this signal may already has been emit
if (removeCount == 0) {
qWarning() << "Job already has been removed: " << path.path();
return false;
}
unregisterObjectFromDBus(path.path());
return true;
}

68
src/dbus/jobmanager1service.h
View File

@ -14,14 +14,30 @@
#include <QtConcurrent>
#include <QFuture>
#include <QUuid>
#include "jobadaptor.h"
#include "global.h"
#include "jobadaptor.h"
class ApplicationManager1Service;
struct LaunchTask
{
LaunchTask();
~LaunchTask() = default;
LaunchTask(const LaunchTask &) = default;
LaunchTask(LaunchTask &&) = default;
LaunchTask &operator=(const LaunchTask &) = default;
LaunchTask &operator=(LaunchTask &&) = default;
QString LaunchBin;
QStringList command;
QVariantList Resources;
};
Q_DECLARE_METATYPE(LaunchTask)
class JobManager1Service final : public QObject
{
Q_OBJECT
public:
JobManager1Service();
JobManager1Service(const JobManager1Service &) = delete;
JobManager1Service(JobManager1Service &&) = delete;
JobManager1Service &operator=(const JobManager1Service &) = delete;
@ -29,48 +45,48 @@ public:
~JobManager1Service() override;
template <typename F>
void addJob(const QDBusObjectPath &source, F func, QVariantList args)
QDBusObjectPath addJob(QString source, F func, QVariantList args)
{
static_assert(std::is_invocable_v<F, QVariant>, "param type must be QVariant.");
QString objectPath{DDEApplicationManager1JobObjectPath + QUuid::createUuid().toString(QUuid::Id128)};
auto future = QtConcurrent::mappedReduced(args.begin(),
args.end(),
func,
qOverload<QVariantList::parameter_type>(&QVariantList::append),
QVariantList{},
QtConcurrent::ReduceOption::OrderedReduce);
QFuture<QVariantList> future = QtConcurrent::mappedReduced(std::move(args),
func,
qOverload<QVariantList::parameter_type>(&QVariantList::append),
QVariantList{},
QtConcurrent::ReduceOption::OrderedReduce);
QSharedPointer<JobService> job{new JobService{future}};
if (!registerObjectToDBus(new JobAdaptor(job.data()), objectPath, getDBusInterface<JobAdaptor>())) {
qCritical() << "can't register job to dbus.";
future.cancel();
return {};
}
auto path = QDBusObjectPath{objectPath};
{
QMutexLocker locker{&m_mutex};
m_jobs.insert(path, job); // Insertion is always successful
m_jobs.insert(path, std::move(job)); // Insertion is always successful
}
emit JobNew(path, source);
registerObjectToDbus(new JobAdaptor(job.data()), objectPath, getDBusInterface<JobAdaptor>());
emit JobNew(path, QDBusObjectPath{source});
auto emitRemove = [this, job, path, future](QVariantList value) {
decltype(m_jobs)::size_type removeCount{0};
{
QMutexLocker locker{&m_mutex};
removeCount = m_jobs.remove(path);
}
// removeCount means m_jobs can't find value which corresponding with path
// and we shouldn't emit jobRemoved signal because this signal may already has been emit
if (removeCount == 0) {
qCritical() << "Job already has been removed: " << path.path();
if (!removeOneJob(path)) {
return value;
}
QString result{job->status()};
for (const auto &val : future.result()) {
if (val.template canConvert<QDBusError>()) {
if (val.canConvert<QDBusError>()) {
result = "failed";
}
break;
}
emit this->JobRemoved(path, result, future.result());
emit JobRemoved(path, result, future.result());
return value;
};
future.then(emitRemove);
future.then(this, emitRemove);
return path;
}
Q_SIGNALS:
@ -78,8 +94,12 @@ Q_SIGNALS:
void JobRemoved(const QDBusObjectPath &job, const QString &status, const QVariantList &result);
private:
bool removeOneJob(const QDBusObjectPath &path);
friend class ApplicationManager1Service;
JobManager1Service(ApplicationManager1Service *parent);
QMutex m_mutex;
QMap<QDBusObjectPath, QSharedPointer<JobService>> m_jobs;
ApplicationManager1Service *m_parent{nullptr};
};
#endif

53
src/desktopentry.cpp
View File

@ -24,8 +24,10 @@ auto DesktopEntry::parserGroupHeader(const QString &str) noexcept
ParseError DesktopEntry::parseEntry(const QString &str, decltype(m_entryMap)::iterator &currentGroup) noexcept
{
if (str.startsWith("#"))
if (str.startsWith("#")) {
return ParseError::NoError;
}
auto splitCharIndex = str.indexOf(']');
if (splitCharIndex != -1) {
for (; splitCharIndex < str.size(); ++splitCharIndex) {
@ -60,7 +62,6 @@ ParseError DesktopEntry::parseEntry(const QString &str, decltype(m_entryMap)::it
if (auto locale = matcher.captured("LOCALE"); !locale.isEmpty()) {
valueKey = locale;
}
qDebug() << valueKey << valueStr;
if (auto cur = currentGroup->find(key); cur == currentGroup->end()) {
currentGroup->insert(keyStr, {{valueKey, valueStr}});
return ParseError::NoError;
@ -93,8 +94,10 @@ std::optional<DesktopFile> DesktopFile::searchDesktopFile(const QString &desktop
qDebug() << "Current Application Dirs:" << XDGDataDirs;
for (const auto &d : XDGDataDirs) {
auto dirPath = QDir::cleanPath(d);
QDirIterator it{
dirPath, {desktopFile}, QDir::AllEntries | QDir::NoSymLinks | QDir::NoDotAndDotDot, QDirIterator::Subdirectories};
QDirIterator it{dirPath,
{desktopFile},
QDir::Files | QDir::NoSymLinks | QDir::NoDotAndDotDot | QDir::Readable,
QDirIterator::Subdirectories};
if (it.hasNext()) {
path = it.next();
break;
@ -107,8 +110,8 @@ std::optional<DesktopFile> DesktopFile::searchDesktopFile(const QString &desktop
err = ParseError::NotFound;
return std::nullopt;
}
auto components = path.split(QDir::separator()).toList();
auto tmp = path.chopped(8); // remove ".desktop"
auto components = tmp.split(QDir::separator()).toList();
auto it = std::find(components.cbegin(), components.cend(), "applications");
if (it == components.cend()) {
qWarning() << "custom location detected, Id wouldn't be generated.";
@ -117,12 +120,24 @@ std::optional<DesktopFile> DesktopFile::searchDesktopFile(const QString &desktop
++it;
while (it != components.cend())
FileId += (*(it++) + "-");
id = FileId.chopped(1);
id = FileId.chopped(1); // remove extra "-""
}
err = ParseError::NoError;
return DesktopFile{std::move(path), std::move(id)};
}
ParseError DesktopEntry::parse(const DesktopFile &desktopFile) noexcept
{
auto file = QFile(desktopFile.filePath());
if (!file.open(QFile::ExistingOnly | QFile::ReadOnly | QFile::Text)) {
qWarning() << desktopFile.filePath() << "can't open.";
return ParseError::OpenFailed;
}
QTextStream in{&file};
return parse(in);
}
ParseError DesktopEntry::parse(QTextStream &stream) noexcept
{
if (stream.atEnd())
@ -135,6 +150,10 @@ ParseError DesktopEntry::parse(QTextStream &stream) noexcept
while (!stream.atEnd()) {
auto line = stream.readLine().trimmed();
if (line.isEmpty()) {
continue;
}
if (line.startsWith("[")) {
if (!line.endsWith("]"))
return ParseError::GroupHeaderInvalid;
@ -150,11 +169,27 @@ ParseError DesktopEntry::parse(QTextStream &stream) noexcept
return err;
}
QMap<QString, DesktopEntry::Value> DesktopEntry::group(const QString &key) const noexcept
std::optional<QMap<QString, DesktopEntry::Value>> DesktopEntry::group(const QString &key) const noexcept
{
if (auto group = m_entryMap.find(key); group != m_entryMap.cend())
return *group;
return {};
return std::nullopt;
}
std::optional<DesktopEntry::Value> DesktopEntry::value(const QString &groupKey, const QString &valueKey) const noexcept
{
const auto &destGroup = group(groupKey);
if (!destGroup) {
qWarning() << "group " << groupKey << " can't be found.";
return std::nullopt;
}
auto it = destGroup->find(valueKey);
if (it == destGroup->cend()) {
qWarning() << "value " << valueKey << " can't be found.";
return std::nullopt;
}
return *it;
}
QString DesktopEntry::Value::unescape(const QString &str) const noexcept

0
src/desktopicons.cpp Normal file
View File

19
src/include/cgroupsidentifier.h Normal file
View File

@ -0,0 +1,19 @@
// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd.
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#ifndef CGROUPSIDENTIFIER_H
#define CGROUPSIDENTIFIER_H
#include "identifier.h"
class CGroupsIdentifier : public Identifier
{
public:
IdentifyRet Identify(pid_t pid) override;
private:
[[nodiscard]] QString parseCGroupsPath(QString path) const noexcept;
};
#endif

51
src/include/desktopentry.h
View File

@ -13,6 +13,29 @@ constexpr static auto defaultKeyStr = "default";
enum class ParseError { NoError, NotFound, MismatchedFile, InvalidLocation, OpenFailed, GroupHeaderInvalid, EntryKeyInvalid };
struct DesktopFile
{
DesktopFile(const DesktopFile &) = default;
DesktopFile(DesktopFile &&) = default;
DesktopFile &operator=(const DesktopFile &) = default;
DesktopFile &operator=(DesktopFile &&) = default;
~DesktopFile() = default;
const QString &filePath() const { return m_filePath; }
const QString &desktopId() const { return m_desktopId; }
static std::optional<DesktopFile> searchDesktopFile(const QString &desktopFilePath, ParseError &err) noexcept;
private:
DesktopFile(QString &&path, QString &&fileId)
: m_filePath(std::move(path))
, m_desktopId(std::move(fileId))
{
}
QString m_filePath{""};
QString m_desktopId{""};
};
class DesktopEntry
{
public:
@ -33,39 +56,17 @@ public:
DesktopEntry() = default;
~DesktopEntry() = default;
[[nodiscard]] ParseError parse(const DesktopFile &file) noexcept;
[[nodiscard]] ParseError parse(QTextStream &stream) noexcept;
[[nodiscard]] QMap<QString, Value> group(const QString &key) const noexcept;
[[nodiscard]] std::optional<QMap<QString, Value>> group(const QString &key) const noexcept;
[[nodiscard]] std::optional<Value> value(const QString &key, const QString &valueKey) const noexcept;
private:
QMap<QString, QMap<QString, Value>> m_entryMap;
auto parserGroupHeader(const QString &str) noexcept;
ParseError parseEntry(const QString &str, decltype(m_entryMap)::iterator &currentGroup) noexcept;
};
struct DesktopFile
{
DesktopFile(const DesktopFile &) = default;
DesktopFile(DesktopFile &&) = default;
DesktopFile &operator=(const DesktopFile &) = default;
DesktopFile &operator=(DesktopFile &&) = default;
~DesktopFile() = default;
const QString &filePath() const { return m_filePath; }
const QString &desktopId() const { return m_desktopId; }
static std::optional<DesktopFile> searchDesktopFile(const QString &desktopFilePath, ParseError &err) noexcept;
private:
DesktopFile(QString &&path, QString &&fileId)
: m_filePath(std::move(path))
, m_desktopId(std::move(fileId))
{
}
QString m_filePath;
QString m_desktopId;
};
QDebug operator<<(QDebug debug, const DesktopEntry::Value &v);
QDebug operator<<(QDebug debug, const ParseError &v);

21
src/include/desktopicons.h Normal file
View File

@ -0,0 +1,21 @@
// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd.
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#ifndef DESKTOPICONS_H
#define DESKTOPICONS_H
#include "global.h"
class DesktopIcons
{
public:
DesktopIcons() = default;
const IconMap &icons() const noexcept { return m_icons; }
IconMap &iconsRef() noexcept { return m_icons; }
private:
IconMap m_icons;
};
#endif

134
src/include/global.h
View File

@ -13,14 +13,27 @@
#include <QDBusError>
#include <QMetaType>
#include <QMetaClassInfo>
#include <QLocale>
#include <QRegularExpression>
#include <QDBusObjectPath>
#include <unistd.h>
#include <optional>
using IconMap = QMap<QString, QMap<uint, QMap<QString, QDBusUnixFileDescriptor>>>;
constexpr auto DDEApplicationManager1ServiceName = u8"org.deepin.dde.ApplicationManager1";
constexpr auto DDEApplicationManager1ObjectPath = u8"/org/deepin/dde/ApplicationManager1";
constexpr auto DDEApplicationManager1ApplicationObjectPath = u8"/org/deepin/dde/ApplicationManager1/Application/";
constexpr auto DDEApplicationManager1InstanceObjectPath = u8"/org/deepin/dde/ApplicationManager1/Instance/";
constexpr auto DDEApplicationManager1JobManagerObjectPath = u8"/org/deepin/dde/ApplicationManager1/JobManager1";
constexpr auto DDEApplicationManager1JobObjectPath = u8"/org/deepin/dde/ApplicationManager1/JobManager1/Job/";
constexpr auto DesktopFileEntryKey = u8"Desktop Entry";
constexpr auto DesktopFileActionKey = u8"Desktop Action ";
constexpr auto ApplicationLauncherBinary =
u8"/home/heyuming/workspace/dde-application-manager/build/plugin/appLauncher/am-launcher";
constexpr auto ApplicationManagerDBusName = u8"deepin_application_manager_bus";
enum class DBusType { Session = QDBusConnection::SessionBus, System = QDBusConnection::SystemBus, Custom };
class ApplicationManager1DBus
{
@ -30,15 +43,52 @@ public:
ApplicationManager1DBus &operator=(const ApplicationManager1DBus &) = delete;
ApplicationManager1DBus &operator=(ApplicationManager1DBus &&) = delete;
const QString &BusAddress() { return m_busAddress; }
void setBusAddress(const QString &address) { m_busAddress = address; }
QDBusConnection &CustomBus()
void init(DBusType type, const QString &busAddress = "")
{
static auto con = QDBusConnection::connectToBus(m_busAddress, "org.deepin.dde.ApplicationManager1");
if (!con.isConnected()) {
qWarning() << con.lastError();
std::terminate();
if (m_initFlag) {
return;
}
return con;
m_busAddress = busAddress;
m_type = type;
m_initFlag = true;
return;
}
QDBusConnection &globalBus()
{
if (m_connection.has_value()) {
return m_connection.value();
}
if (!m_initFlag) {
qFatal() << "invoke init at first.";
}
switch (m_type) {
case DBusType::Session:
[[fallthrough]];
case DBusType::System: {
m_connection.emplace(
QDBusConnection::connectToBus(static_cast<QDBusConnection::BusType>(m_type), ApplicationManagerDBusName));
if (!m_connection->isConnected()) {
qFatal() << m_connection->lastError();
}
return m_connection.value();
}
case DBusType::Custom: {
if (m_busAddress.isEmpty()) {
qFatal() << "connect to custom dbus must init this object by custom dbus address";
}
m_connection.emplace(
QDBusConnection::connectToBus(static_cast<QDBusConnection::BusType>(m_type), ApplicationManagerDBusName));
if (!m_connection->isConnected()) {
qFatal() << m_connection->lastError();
}
return m_connection.value();
}
}
Q_UNREACHABLE();
}
static ApplicationManager1DBus &instance()
{
@ -49,10 +99,14 @@ public:
private:
ApplicationManager1DBus() = default;
~ApplicationManager1DBus() = default;
bool m_initFlag;
DBusType m_type;
QString m_busAddress;
std::optional<QDBusConnection> m_connection{std::nullopt};
};
bool registerObjectToDbus(QObject *o, const QString &path, const QString &interface);
bool registerObjectToDBus(QObject *o, const QString &path, const QString &interface);
void unregisterObjectFromDBus(const QString &path);
template <typename T>
QString getDBusInterface()
@ -62,7 +116,71 @@ QString getDBusInterface()
if (auto infoIndex = infoObject->indexOfClassInfo("D-Bus Interface"); infoIndex != -1) {
return infoObject->classInfo(infoIndex).value();
}
qWarning() << "no interface found.";
return {};
}
inline uid_t getCurrentUID()
{
return getuid(); // current use linux getuid
}
inline QLocale getUserLocale()
{
return QLocale::system(); // current use env
}
inline QString unescapeString(const QString &input)
{
QRegularExpression regex("\\\\x([0-9A-Fa-f]{2})");
QRegularExpressionMatchIterator it = regex.globalMatch(input);
QString output{input};
while (it.hasNext()) {
QRegularExpressionMatch match = it.next();
bool ok;
// Get the hexadecimal value from the match and convert it to a number.
int asciiValue = match.captured(1).toInt(&ok, 16);
if (ok) {
// Convert the ASCII value to a QChar and perform the replacement.
output.replace(match.capturedStart(), match.capturedLength(), QChar(asciiValue));
}
}
return output;
}
inline QString escapeToObjectPath(const QString &str)
{
if (str.isEmpty()) {
return "_";
}
auto ret = str;
QRegularExpression re{R"([^a-zA-Z0-9])"};
auto matcher = re.globalMatch(ret);
while (matcher.hasNext()) {
auto replaceList = matcher.next().capturedTexts();
replaceList.removeDuplicates();
for (const auto &c : replaceList) {
auto hexStr = QString::number(static_cast<uint>(c.front().toLatin1()), 16);
ret.replace(c, QString{R"(_%1)"}.arg(hexStr));
}
}
return ret;
}
inline QString unescapeFromObjectPath(const QString &str)
{
auto ret = str;
for (qsizetype i = 0; i < str.size(); ++i) {
if (str[i] == '_' and i + 2 < str.size()) {
auto hexStr = str.sliced(i + 1, 2);
ret.replace(hexStr, QChar::fromLatin1(hexStr.toUInt(nullptr, 16)));
i += 2;
}
}
return ret;
}
#endif

24
src/include/identifier.h Normal file
View File

@ -0,0 +1,24 @@
// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd.
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#ifndef IDENTIFIER_H
#define IDENTIFIER_H
#include <QString>
#include <unistd.h>
struct IdentifyRet
{
QString ApplicationId;
QString InstanceId;
};
class Identifier
{
public:
virtual ~Identifier() = default;
virtual IdentifyRet Identify(pid_t pid) = 0;
};
#endif

59
src/main.cpp
View File

@ -1,4 +1,59 @@
int main()
// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd.
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#include "global.h"
#include <QDBusConnection>
#include <QCoreApplication>
#include <QDir>
#include "applicationmanager1service.h"
#include "cgroupsidentifier.h"
#include "global.h"
static void registerComplexDbusType()
{
return 0;
qDBusRegisterMetaType<QMap<QString, QDBusUnixFileDescriptor>>();
qDBusRegisterMetaType<QMap<uint, QMap<QString, QDBusUnixFileDescriptor>>>();
qDBusRegisterMetaType<IconMap>();
}
int main(int argc, char *argv[])
{
QCoreApplication app{argc, argv};
auto &bus = ApplicationManager1DBus::instance();
bus.init(DBusType::Session);
auto &AMBus = bus.globalBus();
registerComplexDbusType();
ApplicationManager1Service AMService{std::make_unique<CGroupsIdentifier>(), AMBus};
QList<DesktopFile> fileList{};
auto pathEnv = qgetenv("XDG_DATA_DIRS");
if (pathEnv.isEmpty()) {
qFatal() << "environment variable $XDG_DATA_DIRS is empty.";
}
auto desktopFileDirs = pathEnv.split(':');
for (const auto &dir : desktopFileDirs) {
auto dirPath = QDir{QDir::cleanPath(dir) + "/applications"};
if (!dirPath.exists()) {
continue;
}
QDirIterator it{dirPath.absolutePath(),
{"*.desktop"},
QDir::Files | QDir::NoSymLinks | QDir::NoDotAndDotDot | QDir::Readable,
QDirIterator::Subdirectories};
while (it.hasNext()) {
auto file = it.next();
ParseError err;
auto ret = DesktopFile::searchDesktopFile(file, err);
if (!ret.has_value()) {
continue;
}
if (!AMService.addApplication(std::move(ret).value())) {
break;
}
}
}
return app.exec();
}

21
src/utils.cpp
View File

@ -1,11 +1,22 @@
// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd.
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#include "global.h"
bool registerObjectToDbus(QObject *o, const QString &path, const QString &interface)
bool registerObjectToDBus(QObject *o, const QString &path, const QString &interface)
{
auto &con = ApplicationManager1DBus::instance().CustomBus();
if (!con.registerObject(path, interface, o)) {
qCritical() << "register object failed:" << path << interface << con.lastError();
return false;
auto &con = ApplicationManager1DBus::instance().globalBus();
if (!con.registerObject(path, interface, o, QDBusConnection::RegisterOption::ExportAllContents)) {
qFatal() << "register object failed:" << path << interface << con.lastError();
} else {
qInfo() << "register object:" << path << interface;
}
return true;
}
void unregisterObjectFromDBus(const QString &path)
{
auto &con = ApplicationManager1DBus::instance().globalBus();
con.unregisterObject(path);
}