plugins/IndicatorsClient/indicatorsmanager.cpp · unity8

git.iko.soy/unity8

on a4713ff help sign in

unity8/plugins/IndicatorsClient/indicatorsmanager.cpp

289 lines 8.0 kB history raw

1/*

3 *

4 * Authors:

5 * Michał Sawicz <michal.sawicz@canonical.com>

6 *

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

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

9 * the Free Software Foundation; version 3.

10 *

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

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

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

14 * GNU General Public License for more details.

15 *

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

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

18 */

20#include "indicatorsmanager.h"

21#include "indicatorsfactory.h"

23#include <QStandardPaths>

24#include <QSettings>

25#include <QDebug>

28class IndicatorsManager::IndicatorData

29{

30public:

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

32 : m_name(name)

33 , m_fileInfo(fileInfo)

34 , m_verified (true)

35 {}

37 QString m_name;

38 QFileInfo m_fileInfo;

40 bool m_verified;

41 IndicatorClientInterface::Ptr m_obj;

42};

44IndicatorsManager::IndicatorsManager(QObject* parent)

45: QObject(parent)

46, m_loaded(false)

47{

48}

50IndicatorsManager::~IndicatorsManager()

51{

52 unload();

53}

55void IndicatorsManager::load()

56{

57 unload();

58 QStringList xdgLocations = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);

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

62 Q_FOREACH(const QString& xdgLocation, xdgLocations)

63 {

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

65 QDir indicator_dir(indicator_path);

66 if (indicator_dir.exists())

67 {

68 // watch folder for changes.

69 m_fsWatcher->addPath(indicator_path);

71 load(indicator_dir);

72 }

73 }

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

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

77 setLoaded(true);

78}

80void IndicatorsManager::onDirectoryChanged(const QString& direcory)

81{

82 load(QDir(direcory));

83}

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

86{

87 QFileInfo file_info(file);

88 if (!file_info.exists())

89 {

90 unload(file_info);

91 return;

92 }

93 else

94 {

95 load(QFileInfo(file));

96 }

97}

99void IndicatorsManager::load(const QDir& dir)

100{

101 startVerify(dir.canonicalPath());

102

103 QFileInfoList indicator_files = dir.entryInfoList(QStringList() << "*.indicator", QDir::Files);

104 Q_FOREACH(const QFileInfo& indicator_file, indicator_files)

105 {

106 load(indicator_file);

107 }

108

109 endVerify(dir.canonicalPath());

110}

111

112void IndicatorsManager::load(const QFileInfo& file_info)

113{

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

115 indicator_settings.beginGroup("Indicator Service");

116 QString name = indicator_settings.value("Name").toString();

117

118 // don't bother loading if it's not registered.

119 if (!IndicatorsFactory::instance().isRegistered(name))

120 {

121 qWarning() << Q_FUNC_INFO << "Invalid plugin name: " << name << " - not registered in factory.";

122 return;

123 }

124

125 auto iter = m_indicatorsData.find(name);

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

127 {

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

129 IndicatorData* currentData = (*iter);

130 currentData->m_verified = true;

131

132 int file_info_location = -1;

133 int current_data_location = -1;

134

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

136

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

138 // from a lower priority standard path

139 QStringList xdgLocations = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);

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

141 {

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

143

144 if (newFileInfoDir == indicatorDir)

145 file_info_location = i;

146 if (currentDataDir == indicatorDir)

147 current_data_location = i;

148

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

150 break;

151 }

152

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

154 if (file_info_location <= current_data_location &&

155 file_info != currentData->m_fileInfo)

156 {

157 currentData->m_fileInfo = file_info;

158 Q_EMIT indicatorLoaded(name);

159 }

160 }

161 else

162 {

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

164 data->m_verified = true;

165 m_indicatorsData[name]= data;

166 Q_EMIT indicatorLoaded(name);

167 }

168}

169

170void IndicatorsManager::unload()

171{

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

173 while(iter.hasNext())

174 {

175 iter.next();

176 IndicatorData* data = iter.value();

177 if (data->m_obj)

178 {

179 data->m_obj->shutdown();

180 }

181 Q_EMIT indicatorAboutToBeUnloaded(iter.key());

182 }

183

184 qDeleteAll(m_indicatorsData);

185 m_indicatorsData.clear();

186

187 setLoaded(false);

188}

189

190void IndicatorsManager::unload(const QFileInfo& file)

191{

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

193 while(iter.hasNext())

194 {

195 iter.next();

196 IndicatorData* data = iter.value();

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

198 {

199 if (!data->m_verified)

200 {

201 QString name = data->m_name;

202 Q_EMIT indicatorAboutToBeUnloaded(name);

203

204 delete data;

205 iter.remove();

206 }

207 }

208 }

209

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

211}

212

213void IndicatorsManager::setLoaded(bool loaded)

214{

215 if (loaded != m_loaded)

216 {

217 m_loaded = loaded;

218 Q_EMIT loadedChanged(m_loaded);

219 }

220}

221

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

223{

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

225 while(iter.hasNext())

226 {

227 iter.next();

228 IndicatorData* data = iter.value();

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

230 data->m_verified = false;

231 }

232}

233

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

235{

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

237 while(iter.hasNext())

238 {

239 iter.next();

240 IndicatorData* data = iter.value();

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

242 {

243 if (!data->m_verified)

244 {

245 QString name = data->m_name;

246 Q_EMIT indicatorAboutToBeUnloaded(name);

247

248 delete data;

249 iter.remove();

250 }

251 }

252 }

253}

254

255IndicatorClientInterface::Ptr IndicatorsManager::indicator(const QString& indicator)

256{

257 if (!m_indicatorsData.contains(indicator)) {

258 qWarning() << Q_FUNC_INFO << "Invalid plugin name: " << indicator;

259 return 0;

260 }

261

262 IndicatorData *data = m_indicatorsData[indicator];

263 if (data->m_obj)

264 return data->m_obj;

265

266 IndicatorClientInterface::Ptr plugin = IndicatorsFactory::instance().create(indicator, this);

267 if (plugin)

268 {

269 data->m_obj = plugin;

270 plugin->init(QSettings(data->m_fileInfo.absoluteFilePath(), QSettings::IniFormat, this));

271 }

272 return plugin;

273}

274

275QList<IndicatorClientInterface::Ptr> IndicatorsManager::indicators()

276{

277 QList<IndicatorClientInterface::Ptr> list;

278 Q_FOREACH(IndicatorData* data, m_indicatorsData)

279 {

280 IndicatorClientInterface::Ptr plugin = indicator(data->m_name);

281 list.append(plugin);

282 }

283 return list;

284}

285

286bool IndicatorsManager::isLoaded() const

287{

288 return m_loaded;

289}