plugins/Unity/Indicators/indicatorsmanager.cpp · unity8

git.iko.soy/unity8

on 04462d0 help sign in

unity8/plugins/Unity/Indicators/indicatorsmanager.cpp

326 lines 8.9 kB history raw

1/*

3 *

4 * This program is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU General Public License as published by

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU General Public License for more details.

12 *

13 * You should have received a copy of the GNU General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 *

16 * Author: Nick Dedekind <nick.dedekind@canonical.com>

17 */

19#include "indicatorsmanager.h"

21#include <QSettings>

22#include <QDebug>

24#include <upstart.h>

25#include <nih/alloc.h>

27#include "paths.h"

29const QString profile = "phone";

32class IndicatorsManager::IndicatorData

33{

34public:

35 IndicatorData(const QString& name, const QFileInfo& fileInfo)

36 : m_name(name)

37 , m_fileInfo(fileInfo)

38 , m_verified (true)

39 {

40 }

42 QString m_name;

43 QFileInfo m_fileInfo;

45 bool m_verified;

46 Indicator::Ptr m_indicator;

47};

49IndicatorsManager::IndicatorsManager(QObject* parent)

50 : QObject(parent)

51 , m_loaded(false)

52 , m_upstart(NULL)

53{

54 auto upstartsession = qgetenv("UPSTART_SESSION");

55 if (!upstartsession.isNull()) {

56 DBusConnection * conn = NULL;

57 conn = dbus_connection_open(upstartsession.constData(), NULL);

58 if (conn != NULL) {

59 m_upstart = nih_dbus_proxy_new(NULL, conn,

60 NULL,

61 DBUS_PATH_UPSTART,

62 NULL, NULL);

63 dbus_connection_unref(conn);

64 }

65 }

67 if (m_upstart != NULL) {

68 m_upstart->auto_start = FALSE;

69 }

70}

72IndicatorsManager::~IndicatorsManager()

73{

74 unload();

76 if (m_upstart != NULL) {

77 nih_unref(m_upstart, NULL);

78 m_upstart = NULL;

79 }

80}

82void IndicatorsManager::load()

83{

84 unload();

85 QStringList xdgLocations = shellDataDirs();//QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);

87 m_fsWatcher.reset(new QFileSystemWatcher(this));

89 Q_FOREACH(const QString& xdgLocation, xdgLocations)

90 {

91 QString indicator_path = QDir::cleanPath(xdgLocation + "/unity/indicators");

92 QDir indicator_dir(indicator_path);

93 if (indicator_dir.exists())

94 {

95 // watch folder for changes.

96 m_fsWatcher->addPath(indicator_path);

98 loadDir(indicator_dir);

99 }

100 }

101

102 QObject::connect(m_fsWatcher.data(), SIGNAL(directoryChanged(const QString&)), this, SLOT(onDirectoryChanged(const QString&)));

103 QObject::connect(m_fsWatcher.data(), SIGNAL(fileChanged(const QString&)), this, SLOT(onFileChanged(const QString&)));

104 setLoaded(true);

105}

106

107void IndicatorsManager::onDirectoryChanged(const QString& directory)

108{

109 loadDir(QDir(directory));

110}

111

112void IndicatorsManager::onFileChanged(const QString& file)

113{

114 QFileInfo file_info(file);

115 if (!file_info.exists())

116 {

117 unloadFile(file_info);

118 return;

119 }

120 else

121 {

122 loadFile(QFileInfo(file));

123 }

124}

125

126void IndicatorsManager::loadDir(const QDir& dir)

127{

128 startVerify(dir.canonicalPath());

129

130 QFileInfoList indicator_files = dir.entryInfoList(QStringList(), QDir::Files|QDir::NoDotAndDotDot);

131 Q_FOREACH(const QFileInfo& indicator_file, indicator_files)

132 {

133 loadFile(indicator_file);

134 }

135

136 endVerify(dir.canonicalPath());

137}

138

139void IndicatorsManager::loadFile(const QFileInfo& file_info)

140{

141 QSettings indicator_settings(file_info.absoluteFilePath(), QSettings::IniFormat, this);

142 QString name = indicator_settings.value("Indicator Service/Name").toString();

143

144 auto iter = m_indicatorsData.find(name);

145 if (iter != m_indicatorsData.end())

146 {

147 QString newFileInfoDir = QDir::cleanPath(file_info.canonicalPath());

148 IndicatorData* currentData = (*iter);

149 currentData->m_verified = true;

150

151 int file_info_location = -1;

152 int current_data_location = -1;

153

154 QString currentDataDir = QDir::cleanPath(currentData->m_fileInfo.canonicalPath());

155

156 // if we've already got this indicator, we need to make sure we're not overwriting data which is

157 // from a lower priority standard path

158 QStringList xdgLocations = shellDataDirs();

159 for (int i = 0; i < xdgLocations.size(); i++)

160 {

161 QString indicatorDir = QDir::cleanPath(xdgLocations[i] + "/unity/indicators");

162

163 if (newFileInfoDir == indicatorDir)

164 {

165 file_info_location = i;

166 }

167 if (currentDataDir == indicatorDir)

168 {

169 current_data_location = i;

170 }

171

172 if (file_info_location != -1 && current_data_location != -1)

173 {

174 break;

175 }

176 }

177

178 // file location is higher (or of equal) priority. overwrite.

179 if (file_info_location <= current_data_location &&

180 file_info != currentData->m_fileInfo)

181 {

182 currentData->m_fileInfo = file_info;

183 Q_EMIT indicatorLoaded(name);

184 }

185 }

186 else

187 {

188 IndicatorData* data = new IndicatorData(name, file_info);

189 data->m_verified = true;

190 m_indicatorsData[name]= data;

191 Q_EMIT indicatorLoaded(name);

192 }

193}

194

195void IndicatorsManager::unload()

196{

197 QHashIterator<QString, IndicatorData*> iter(m_indicatorsData);

198 while(iter.hasNext())

199 {

200 iter.next();

201 Q_EMIT indicatorAboutToBeUnloaded(iter.key());

202 }

203

204 qDeleteAll(m_indicatorsData);

205 m_indicatorsData.clear();

206

207 setLoaded(false);

208}

209

210void IndicatorsManager::unloadFile(const QFileInfo& file)

211{

212 QMutableHashIterator<QString, IndicatorData*> iter(m_indicatorsData);

213 while(iter.hasNext())

214 {

215 iter.next();

216 IndicatorData* data = iter.value();

217 if (data->m_fileInfo.absoluteFilePath() == file.absoluteFilePath())

218 {

219 if (!data->m_verified)

220 {

221 QString name = data->m_name;

222 Q_EMIT indicatorAboutToBeUnloaded(name);

223

224 delete data;

225 iter.remove();

226 }

227 }

228 }

229

230 setLoaded(m_indicatorsData.size() > 0);

231}

232

233void IndicatorsManager::setLoaded(bool loaded)

234{

235 if (loaded != m_loaded)

236 {

237 m_loaded = loaded;

238 Q_EMIT loadedChanged(m_loaded);

239

240 if (m_upstart != NULL) {

241 int event_sent = 0;

242 if (m_loaded) {

243 event_sent = upstart_emit_event_sync(NULL, m_upstart, "indicator-services-start", NULL, 0);

244 } else {

245 event_sent = upstart_emit_event_sync(NULL, m_upstart, "indicator-services-end", NULL, 0);

246 }

247

248 if (event_sent != 0) {

249 qWarning() << "Unable to send indicator event to Upstart";

250 }

251 }

252 }

253}

254

255void IndicatorsManager::startVerify(const QString& path)

256{

257 QHashIterator<QString, IndicatorData*> iter(m_indicatorsData);

258 while(iter.hasNext())

259 {

260 iter.next();

261 IndicatorData* data = iter.value();

262 if (data->m_fileInfo.canonicalPath() == path)

263 {

264 data->m_verified = false;

265 }

266 }

267}

268

269void IndicatorsManager::endVerify(const QString& path)

270{

271 QMutableHashIterator<QString, IndicatorData*> iter(m_indicatorsData);

272 while(iter.hasNext())

273 {

274 iter.next();

275 IndicatorData* data = iter.value();

276 if (data->m_fileInfo.canonicalPath() == path)

277 {

278 if (!data->m_verified)

279 {

280 QString name = data->m_name;

281 Q_EMIT indicatorAboutToBeUnloaded(name);

282

283 delete data;

284 iter.remove();

285 }

286 }

287 }

288}

289

290Indicator::Ptr IndicatorsManager::indicator(const QString& indicator_name)

291{

292 if (!m_indicatorsData.contains(indicator_name))

293 {

294 qWarning() << Q_FUNC_INFO << "Invalid indicator name: " << indicator_name;

295 return Indicator::Ptr();

296 }

297

298 IndicatorData *data = m_indicatorsData[indicator_name];

299 if (data->m_indicator)

300 {

301 return data->m_indicator;

302 }

303

304 Indicator::Ptr new_indicator(new Indicator(this));

305 data->m_indicator = new_indicator;

306 QSettings settings(data->m_fileInfo.absoluteFilePath(), QSettings::IniFormat, this);

307 new_indicator->init(profile, data->m_fileInfo.fileName(), settings);

308 return new_indicator;

309}

310

311QList<Indicator::Ptr> IndicatorsManager::indicators()

312{

313 QList<Indicator::Ptr> list;

314 Q_FOREACH(IndicatorData* data, m_indicatorsData)

315 {

316 Indicator::Ptr ret = indicator(data->m_name);

317 if (ret)

318 list.append(ret);

319 }

320 return list;

321}

322

323bool IndicatorsManager::isLoaded() const

324{

325 return m_loaded;

326}