tests/mocks/libusermetrics/UserMetrics.cpp · unity8

git.iko.soy/unity8

on fb178ff help sign in

unity8/tests/mocks/libusermetrics/UserMetrics.cpp

474 lines 12 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: Pete Woods <pete.woods@canonical.com>

17 */

19#include "UserMetrics.h"

20#include <qvariantlistmodel.h>

22#include <QtCore/QDir>

23#include <QtCore/QString>

24#include <QtGui/QIcon>

25#include <QMultiMap>

27#include <functional>

28#include <random>

30using namespace UserMetricsOutput;

32namespace UserMetricsOutput

33{

34class UserMetricsDataPrivate;

35class UserMetricsPrivate;

37class Q_DECL_EXPORT UserMetricsData: public QObject

38{

39public:

40 explicit UserMetricsData(QObject *parent);

42 UserMetricsData(const QString &label,

43 const ColorTheme &firstColor,

44 const QVariantList &firstMonth,

45 const ColorTheme &secondColor,

46 const QVariantList &secondMonth, QObject* parent);

48 ~UserMetricsData();

50protected:

51 UserMetricsDataPrivate * const d_ptr;

53public:

54 const QString & label() const;

55 const ColorTheme & firstColor() const;

56 const QVariantList & firstMonth() const;

57 const ColorTheme & secondColor() const;

58 const QVariantList & secondMonth() const;

59 int length() const;

61private:

62 Q_DECLARE_PRIVATE(UserMetricsData)

63};

65class UserMetricsPrivate: QObject

66{

67public:

68 explicit UserMetricsPrivate(UserMetrics *parent);

70 ~UserMetricsPrivate();

72public:

73 typedef QSharedPointer<UserMetricsData> UserMetricsDataPtr;

74 typedef QMultiMap<QString, UserMetricsDataPtr> FakeDataMap;

76 UserMetrics * const q_ptr;

77 QString m_label;

78 ColorTheme m_firstColor;

79 QVariantListModel m_firstMonth;

80 ColorTheme m_secondColor;

81 QVariantListModel m_secondMonth;

82 int m_currentDay;

83 QString m_username;

84 FakeDataMap::const_iterator m_dataIndex;

85 UserMetricsDataPtr m_newData;

86 FakeDataMap m_fakeData;

88 void setUsername(const QString &username);

90protected:

91 void nextFakeData();

93 void generateFakeData();

95 void loadFakeData();

97 void finishSetFakeData();

99private:

100 Q_DECLARE_PUBLIC(UserMetrics)

101};

102

103class UserMetricsDataPrivate: QObject

104{

105public:

106 explicit UserMetricsDataPrivate(UserMetricsData *parent);

107

108 UserMetricsDataPrivate(const QString &label,

109 const ColorTheme &firstColor,

110 const QVariantList &firstMonth,

111 const ColorTheme &secondColor,

112 const QVariantList &secondMonth, UserMetricsData *parent);

113

114 ~UserMetricsDataPrivate();

115

116 UserMetricsData * const q_ptr;

117 QString m_label;

118 ColorTheme m_firstColor;

119 QVariantList m_firstMonth;

120 ColorTheme m_secondColor;

121 QVariantList m_secondMonth;

122 int m_length;

123

124protected:

125 int calculateLength();

126

127private:

128 Q_DECLARE_PUBLIC(UserMetricsData)

129};

130

131}

132

133UserMetricsDataPrivate::UserMetricsDataPrivate(UserMetricsData *parent) :

134 q_ptr(parent), m_firstColor(this), m_secondColor(this)

135{

136 m_length = calculateLength();

137}

138

139UserMetricsDataPrivate::UserMetricsDataPrivate(const QString &label,

140 const ColorTheme &firstColor, const QVariantList &firstMonth,

141 const ColorTheme &secondColor,

142 const QVariantList &secondMonth, UserMetricsData *parent) :

143 q_ptr(parent), m_label(label), m_firstColor(this), m_firstMonth(

144 firstMonth), m_secondColor(this), m_secondMonth(secondMonth)

145{

146 m_length = calculateLength();

147 m_firstColor = firstColor;

148 m_secondColor = secondColor;

149}

150

151UserMetricsDataPrivate::~UserMetricsDataPrivate()

152{

153}

154

155int UserMetricsDataPrivate::calculateLength()

156{

157 int day(m_firstMonth.size());

158 auto it = m_firstMonth.end(), end = m_firstMonth.begin();

159 while (it != end)

160 {

161 --it;

162 --day;

163 if (!it->isNull())

164 {

165 return day;

166 }

167 }

168

169 return -1;

170}

171

172UserMetricsData::UserMetricsData(QObject *parent) :

173 QObject(parent), d_ptr(new UserMetricsDataPrivate(this))

174{

175}

176

177UserMetricsData::UserMetricsData(const QString &label,

178 const ColorTheme &firstColor, const QVariantList &firstMonth,

179 const ColorTheme &secondColor,

180 const QVariantList &secondMonth, QObject* parent) :

181 QObject(parent), d_ptr(

182 new UserMetricsDataPrivate(label, firstColor, firstMonth,

183 secondColor, secondMonth, this))

184{

185}

186

187UserMetricsData::~UserMetricsData()

188{

189 delete d_ptr;

190}

191

192const QString & UserMetricsData::label() const

193{

194 return d_ptr->m_label;

195}

196

197const ColorTheme & UserMetricsData::firstColor() const

198{

199 return d_ptr->m_firstColor;

200}

201

202const QVariantList & UserMetricsData::firstMonth() const

203{

204 return d_ptr->m_firstMonth;

205}

206

207const ColorTheme & UserMetricsData::secondColor() const

208{

209 return d_ptr->m_secondColor;

210}

211

212const QVariantList & UserMetricsData::secondMonth() const

213{

214 return d_ptr->m_secondMonth;

215}

216

217int UserMetricsData::length() const

218{

219 return d_ptr->m_length;

220}

221

222UserMetricsPrivate::UserMetricsPrivate(UserMetrics *parent) :

223 q_ptr(parent), m_firstColor(this), m_secondColor(this), m_currentDay(0)

224{

225 m_fakeData.insert("", UserMetricsDataPtr(new UserMetricsData(this)));

226}

227

228UserMetricsPrivate::~UserMetricsPrivate()

229{

230}

231

232void UserMetricsPrivate::setUsername(const QString &username)

233{

234 if (m_username == username && m_newData) {

235 return;

236 }

237

238 m_username = username;

239

240 m_dataIndex = m_fakeData.constFind(m_username);

241 if (m_dataIndex == m_fakeData.constEnd())

242 {

243 m_dataIndex = m_fakeData.constFind("");

244 }

245

246 loadFakeData();

247

248 q_ptr->usernameChanged(m_username);

249}

250

251void UserMetricsPrivate::generateFakeData()

252{

253 std::default_random_engine generator;

254 std::normal_distribution<qreal> distribution(0.5, 0.2);

255 auto rand = std::bind(distribution, generator);

256

257 QVector<QColor> colours;

258 colours.push_back(QColor::fromRgbF(0.3, 0.27, 0.32));

259 colours.push_back(QColor::fromRgbF(0.83, 0.49, 0.58));

260 colours.push_back(QColor::fromRgbF(0.63, 0.51, 0.59));

261

262 colours.push_back(QColor::fromRgbF(0.28, 0.26, 0.4));

263 colours.push_back(QColor::fromRgbF(0.47, 0.38, 0.56));

264 colours.push_back(QColor::fromRgbF(0.69, 0.65, 0.78));

265

266 colours.push_back(QColor::fromRgbF(0.32, 0.21, 0.16));

267 colours.push_back(QColor::fromRgbF(0.55, 0.45, 0.32));

268 colours.push_back(QColor::fromRgbF(0.85, 0.74, 0.53));

269

270 colours.push_back(QColor::fromRgbF(0.25, 0.31, 0.19));

271 colours.push_back(QColor::fromRgbF(0.63, 0.53, 0.3));

272 colours.push_back(QColor::fromRgbF(0.89, 0.56, 0.31));

273

274 ColorTheme first(colours[0], colours[1], colours[2]);

275 ColorTheme second(colours[3], colours[4], colours[5]);

276 ColorTheme eighth(colours[6], colours[7], colours[8]);

277 ColorTheme ninth(colours[9], colours[10], colours[11]);

278

279 {

280 QVariantList firstMonth;

281 while (firstMonth.size() < 17)

282 firstMonth.push_back(QVariant(rand()));

283 while (firstMonth.size() < 31)

284 firstMonth.push_back(QVariant());

285 QVariantList secondMonth;

286 while (secondMonth.size() < 31)

287 secondMonth.push_back(QVariant(rand()));

288 QSharedPointer<UserMetricsData> data(

289 new UserMetricsData("52km travelled", first, firstMonth,

290 ninth, secondMonth, this));

291 m_fakeData.insert("single", data);

292 m_fakeData.insert("has-pin", data);

293 }

294

295 {

296 QVariantList firstMonth;

297 while (firstMonth.size() < 17)

298 firstMonth.push_back(QVariant(rand()));

299 while (firstMonth.size() < 31)

300 firstMonth.push_back(QVariant());

301 QVariantList secondMonth;

302 while (secondMonth.size() < 31)

303 secondMonth.push_back(QVariant(rand()));

304 QSharedPointer<UserMetricsData> data(

305 new UserMetricsData("33 messages today", second,

306 firstMonth, eighth, secondMonth, this));

307 m_fakeData.insert("single", data);

308 m_fakeData.insert("has-pin", data);

309 }

310

311 {

312 QVariantList firstMonth;

313 while (firstMonth.size() < 17)

314 firstMonth.push_back(QVariant(rand()));

315 firstMonth[8] = QVariant(1.0); // oversized 9th day, to test clipping

316 while (firstMonth.size() < 31)

317 firstMonth.push_back(QVariant());

318 QVariantList secondMonth;

319 while (secondMonth.size() < 31)

320 secondMonth.push_back(QVariant(rand()));

321 QSharedPointer<UserMetricsData> data(

322 new UserMetricsData("19 minutes talk time", eighth,

323 firstMonth, second, secondMonth, this));

324 m_fakeData.insert("single", data);

325 m_fakeData.insert("has-pin", data);

326 // Also use same data for some tablet users

327 m_fakeData.insert("has-password", data);

328 m_fakeData.insert("no-password", data);

329 m_fakeData.insert("empty-name", data);

330 }

331}

332

333void UserMetricsPrivate::loadFakeData()

334{

335 m_newData = *m_dataIndex;

336

337 bool oldLabelEmpty = m_label.isEmpty();

338 bool newLabelEmpty = m_newData->label().isEmpty();

339

340 if (oldLabelEmpty && !newLabelEmpty)

341 {

342 q_ptr->dataAboutToAppear();

343 finishSetFakeData();

344 } else if (!oldLabelEmpty && newLabelEmpty)

345 {

346 q_ptr->dataAboutToDisappear();

347 } else if (!oldLabelEmpty && !newLabelEmpty)

348 {

349 q_ptr->dataAboutToChange();

350 }

351 // we emit no signal if the data has stayed empty

352}

353

354void UserMetricsPrivate::finishSetFakeData()

355{

356 bool oldLabelEmpty = m_label.isEmpty();

357 bool newLabelEmpty = m_newData->label().isEmpty();

358

359 m_label = m_newData->label();

360 m_firstColor = m_newData->firstColor();

361 m_firstMonth.setVariantList(m_newData->firstMonth());

362 m_secondColor = m_newData->secondColor();

363 m_secondMonth.setVariantList(m_newData->secondMonth());

364

365 bool currentDayChanged = m_currentDay != m_newData->length();

366 m_currentDay = m_newData->length();

367

368 q_ptr->labelChanged(m_label);

369 if (currentDayChanged)

370 {

371 q_ptr->currentDayChanged(m_currentDay);

372 }

373

374 if (oldLabelEmpty && !newLabelEmpty)

375 {

376 q_ptr->dataAppeared();

377 } else if (!oldLabelEmpty && newLabelEmpty)

378 {

379 q_ptr->dataDisappeared();

380 } else if (!oldLabelEmpty && !newLabelEmpty)

381 {

382 q_ptr->dataChanged();

383 }

384 // we emit no signal if the data has stayed empty

385}

386

387void UserMetricsPrivate::nextFakeData()

388{

389 ++m_dataIndex;

390 if (m_dataIndex == m_fakeData.constEnd() || m_dataIndex.key() != m_username)

391 {

392 m_dataIndex = m_fakeData.constFind(m_username);

393 if (m_dataIndex == m_fakeData.constEnd())

394 {

395 m_dataIndex = m_fakeData.constFind("");

396 }

397 }

398

399 loadFakeData();

400}

401

402UserMetrics::UserMetrics(QObject *parent) :

403 QObject(parent), d_ptr(new UserMetricsPrivate(this))

404{

405 d_ptr->generateFakeData();

406 setUsername("");

407

408 connect(this, &UserMetrics::nextDataSource, this, &UserMetrics::nextDataSourceSlot, Qt::QueuedConnection);

409 connect(this, &UserMetrics::readyForDataChange, this, &UserMetrics::readyForDataChangeSlot, Qt::QueuedConnection);

410}

411

412UserMetrics::~UserMetrics()

413{

414 delete d_ptr;

415}

416

417QString UserMetrics::label() const

418{

419 return d_ptr->m_label;

420}

421

422QString UserMetrics::username() const

423{

424 return d_ptr->m_username;

425}

426

427void UserMetrics::setUsername(const QString &username)

428{

429 d_ptr->setUsername(username);

430}

431

432ColorTheme *UserMetrics::firstColor() const

433{

434 return &d_ptr->m_firstColor;

435}

436

437ColorTheme *UserMetrics::secondColor() const

438{

439 return &d_ptr->m_secondColor;

440}

441

442QAbstractItemModel *UserMetrics::firstMonth() const

443{

444 return &d_ptr->m_firstMonth;

445}

446

447QAbstractItemModel *UserMetrics::secondMonth() const

448{

449 return &d_ptr->m_secondMonth;

450}

451

452int UserMetrics::currentDay() const

453{

454 return d_ptr->m_currentDay;

455}

456

457void UserMetrics::nextDataSourceSlot()

458{

459 d_ptr->nextFakeData();

460}

461

462void UserMetrics::readyForDataChangeSlot()

463{

464 d_ptr->finishSetFakeData();

465}

466

467/**

468 * Factory methods

469 */

470

471UserMetrics * UserMetrics::getInstance()

472{

473 return new UserMetrics();

474}