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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2019 Luxoft Sweden AB
// Copyright (C) 2018 Pelagicore AG
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <qplatformdefs.h>
#include "application.h"
#include "abstractcontainer.h"
/*!
\qmltype Container
\inqmlmodule QtApplicationManager.SystemUI
\ingroup system-ui-non-instantiable
\brief The handle for a container, that an application's \l Runtime is using.
Instances of this class are available to the System UI via an application's \l Runtime object,
while an application is running. Please see the \l{Containers}{Container documentation} for
an in-depth description of containers within the application manager.
\note Applications running in single-process mode (even ones using the \c qml-inprocess runtime
while the application manager is running in multi-process mode) will have no Container
object associated.
*/
/*!
\qmlproperty string Container::controlGroup
This property lets you get and set which control group the application's container will be in.
If you are using cgroups \b v1, then the control group name handled by this property is \b not
the low-level name used by the operating system, but an abstraction. See the
\l{control group mapping}{container documentation} for more details on how to setup this mapping.
Starting with release 6.8.3 of the application manager, cgroups \b v2 are supported as well. In
this case, the control group name is the low-level cgroup name (or path in \c{/sys/fs/cgroup})
used by the operating system, without any mappings.
\note Control groups are only supported on Linux through the kernel's \c cgroup system in the
built-in \c process container. Custom container plugins might not implement the necessary
interface.
*/
/*!
\qmlproperty bool Container::hasDebugWrapper
\readonly
\since 6.8
Returns \c true, if the runtime in this container is executing with a debug wrapper and \c
false otherwise.
\sa Debugging
*/
QT_BEGIN_NAMESPACE_AM
AbstractContainer::~AbstractContainer()
{ }
/*!
\qmlproperty string Container::containerId
\readonly
\since 6.10
This property returns the \c id of the container that is executing the application. The \c id
is a unique identifier for the container integration and can be used to reference it in other
parts of the System UI or in configuration files.
*/
QString AbstractContainer::containerId() const
{
return m_manager->identifier();
}
QString AbstractContainer::controlGroup() const
{
return QString();
}
bool AbstractContainer::setControlGroup(const QString &groupName)
{
Q_UNUSED(groupName)
return false;
}
bool AbstractContainer::setProgram(const QString &program)
{
if (!m_program.isEmpty())
return false;
m_program = program;
return true;
}
void AbstractContainer::setBaseDirectory(const QString &baseDirectory)
{
m_baseDirectory = baseDirectory;
}
QString AbstractContainer::mapContainerPathToHost(const QString &containerPath) const
{
return containerPath;
}
QString AbstractContainer::mapHostPathToContainer(const QString &hostPath) const
{
return hostPath;
}
AbstractContainerProcess *AbstractContainer::process() const
{
return m_process;
}
void AbstractContainer::setApplication(Application *app)
{
if (app != m_app) {
m_app = app;
emit applicationChanged(app);
}
}
Application *AbstractContainer::application() const
{
return m_app;
}
AbstractContainer::AbstractContainer(AbstractContainerManager *manager, Application *app)
: QObject(manager)
, m_manager(manager)
, m_app(app)
{ }
QVariantMap AbstractContainer::configuration() const
{
if (m_manager)
return m_manager->configuration();
return QVariantMap();
}
AbstractContainerManager::AbstractContainerManager(const QString &id, QObject *parent)
: QObject(parent)
, m_id(id)
{ }
QString AbstractContainerManager::defaultIdentifier()
{
return QString();
}
QString AbstractContainerManager::identifier() const
{
return m_id;
}
bool AbstractContainerManager::supportsQuickLaunch() const
{
return false;
}
QVariantMap AbstractContainerManager::configuration() const
{
return m_configuration;
}
void AbstractContainerManager::setConfiguration(const QVariantMap &configuration)
{
m_configuration = configuration;
}
QT_END_NAMESPACE_AM
#include "moc_abstractcontainer.cpp"
|
