FCL/sf/mw/hb: comparison src/hbservers/hbsplashgenerator/hbsplashgenerator.cpp

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 const char *last_theme_key = "lasttheme";
 const char *last_lang_key = "lastlang";
 const char *last_file_count_key = "lastfilecount";
 const char *last_output_dir_key = "lastoutdir";
+// Using invokeMethod with QueuedConnection is not good enough as it can
+// cause starvation for Symbian active objects (at least in Qt versions
+// before 4.7.2) so the theme change notification would get delayed until
+// an entire regeneration cycle is finished, which is not acceptable. So
+// use a QTimer with a small timeout instead. A small delay is beneficial
+// anyway to divide the load a bit better so perf does not drop that much
+// in apps while regeneration is on-going.
+#define NEXT_STAGE(obj, func) QTimer::singleShot(10, this, SLOT(func()))
 HbSplashGenerator::HbSplashGenerator()
 : mMainWindowLocked(false),
 mProcessQueuePending(false),
 mForceRegen(false),
 mMainWindow(0),
-mFirstRegenerate(true)
+mFirstRegenerate(true),
+mSaveSplFailed(false)
 {
 #if defined(Q_OS_SYMBIAN)
 CCoeEnv::Static()->FsSession().CreatePrivatePath(EDriveC);
 QString iniFileName = QString("c:/private/%1/hbsplashgen.ini")
 .arg(QString::number(hbsplash_server_uid3.iUid, 16));
 static void log(const QString &msg, const QString &theme = QString(), int orientation = -1)
 {
 const char *fmt = PRE " %s ('%s' '%s')";
 QString oriName = orientationName(static_cast<Qt::Orientation>(orientation));
-qDebug(fmt, qPrintable(msg), qPrintable(theme), qPrintable(oriName));
+splDebug(fmt, qPrintable(msg), qPrintable(theme), qPrintable(oriName));
 }
 // To be called on startup and after each fully completed regeneration.
 // Returns the number of files in the output directory.
 int HbSplashGenerator::updateOutputDirContents(const QString &outDir)
 }
 void HbSplashGenerator::start(bool forceRegen)
 {
 mForceRegen = forceRegen;
+// Let's have a certain delay for better load balancing during
+// boot. It is not strictly required, though.
 QTimer::singleShot(5000, this, SLOT(doStart()));
 }
 void HbSplashGenerator::doStart()
 {
-qDebug() << PRE << "accessing theme";
+splDeb() << PRE << "accessing theme";
 // Start listening to the theme-change-finished signal.
 HbTheme *theme = hbInstance->theme();
 connect(theme, SIGNAL(changeFinished()), SLOT(regenerate()));
 // Watch also the directories containing splashml files. Files may
 if (QDir(dir).exists()) {
 mFsWatcher.addPath(dir);
 }
 }
+// Regenerate screens, if needed.
+scheduleRegen();
+}
+void HbSplashGenerator::scheduleRegen()
+{
 // Regenerate screens on startup only when the theme, the language, the
 // number of files in the splash screen directory, or the splash screen
 // directory path is different than the recorded values. (or when
 // regeneration is forced via command line arg)
 QString lastTheme = mSettings->value(QLatin1String(last_theme_key)).toString();
 QString lastLang = mSettings->value(QLatin1String(last_lang_key)).toString();
 int lastFileCount = mSettings->value(QLatin1String(last_file_count_key)).toInt();
 QString lastOutputDir = mSettings->value(QLatin1String(last_output_dir_key)).toString();
-QString currentTheme = theme->name();
+QString currentTheme = hbInstance->theme()->name();
 QString currentLang = QLocale::system().name();
 QString currentOutputDir = hbsplash_output_dir();
 int currentFileCount = updateOutputDirContents(currentOutputDir);
 qDebug() << PRE << "last regen:" << lastTheme << lastLang << lastFileCount << lastOutputDir
 << "current:" << currentTheme << currentLang << currentFileCount << currentOutputDir;
 || currentFileCount == 0 // not having any files is wrong for sure
 || currentTheme != lastTheme
 || currentLang != lastLang
 || currentFileCount != lastFileCount
 || currentOutputDir != lastOutputDir) {
-QMetaObject::invokeMethod(this, "regenerate", Qt::QueuedConnection);
+NEXT_STAGE(this, regenerate);
+mForceRegen = false;
 }
 }
 void HbSplashGenerator::uncachedRegenerate()
 {
 // Same as regenerate() but no caching is used so every file is
 // parsed again.
 mParsedSplashmls.clear();
 regenerate();
+}
+inline void delete_splash_screens()
+{
+QDir outDir(hbsplash_output_dir());
+if (outDir.exists()) {
+QStringList names = outDir.entryList(QStringList() << "*", QDir::Files);
+foreach(const QString & name, names) {
+outDir.remove(name);
+}
+}
 }
 void HbSplashGenerator::regenerate()
 {
 QString themeName = hbInstance->theme()->name();
 try {
 emit regenerateStarted();
 QTime queuePrepTime;
 queuePrepTime.start();
 // Delete existing splash screens. This is important because apps
-// should never pick up a screen with the previous theme or
+// should never pick up a screen with the previous theme or language
-// language. If the generation of the new screens (at least the
+// (not even when generating screens with the new theme fails). If
-// empty view) has not finished when a new app is started then it is
+// the generation of the new screens (at least the empty view) has
-// better to show no splash screen at all.
+// not finished when a new app is started then it is better to show
-QDir outDir(hbsplash_output_dir());
+// no splash screen at all.
-if (outDir.exists()) {
+delete_splash_screens();
-QStringList names = outDir.entryList(QStringList() << "*", QDir::Files);
-foreach(const QString & name, names) {
-outDir.remove(name);
-}
-}
 // Clear the queue, generating screens with a non-current theme is
 // not possible anyway.
 mQueue.clear();
 // If this is the first invocation then put some requests for
 // screens we won't use. On certain platforms the very first
 // Queue the screenshot request for both orientations.
 mQueue.enqueue(QueueItem(themeName, Qt::Vertical));
 mQueue.enqueue(QueueItem(themeName, Qt::Horizontal));
 queueAppSpecificItems(themeName, Qt::Vertical);
 queueAppSpecificItems(themeName, Qt::Horizontal);
-qDebug() << PRE << "queue preparation time (ms):" << queuePrepTime.elapsed();
+mSaveSplFailed = false;
-QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);
+// If a previous regenerate is on-going, the mainwindow is locked
+// and we will not get to process the new queue entries before the
+// one screen, that is in progress, is done. However that one last
+// screen must not be rendered and written to file. To indicate
+// this, use a flag in the first queue entry.
+//
+// Note that removing the metacalls or timers is not an option as
+// that would lead to possibly leaving the mainwindow locked (and we
+// must never unlock it "manually" as it may be locked by some other
+// entity, e.g. the statusbar generator), so we have to let the last
+// screen to finish normally (excluding rendering and storage).
+mQueue.head().mFirstInRegen = true;
+splDeb() << PRE << "queue preparation time (ms):" << queuePrepTime.elapsed();
+NEXT_STAGE(this, processQueue);
 } catch (const std::bad_alloc &) {
 cleanup();
 }
 }
 }
+// This function is for the splashviewer tool only, do not use from elsewhere.
 void HbSplashGenerator::regenerateOne(const QString &splashmlFileName, const QString &customTrDir)
 {
 mQueue.clear();
 QueueItem item(hbInstance->theme()->name(), Qt::Vertical);
 QString path = QFileInfo(splashmlFileName).path();
 parseSplashml(splashmlFileName, item);
 item.mDocmlFileName = QDir(path).filePath(item.mDocmlFileName);
 mQueue.enqueue(item); // generate it regardless of the fixed orientation setting
 item.mOrientation = Qt::Horizontal;
 mQueue.enqueue(item);
-QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);
+NEXT_STAGE(this, processQueue);
 }
 QImage HbSplashGenerator::renderView()
 {
 log("renderView()", mItem.mThemeName, mItem.mOrientation);
 // these images)
 QImage image(mMainWindow->size(), QImage::Format_ARGB32_Premultiplied);
 image.fill(QColor(Qt::transparent).rgba());
 QPainter painter(&image);
 mMainWindow->render(&painter);
-qDebug() << PRE << "rendering time (ms):" << t.elapsed();
+splDeb() << PRE << "rendering time (ms):" << t.elapsed();
 return image;
 }
 void HbSplashGenerator::processQueue()
 {
-qDebug() << PRE << "processQueue()";
+splDeb() << PRE << "processQueue()";
 // If the queue is empty then the splash regeneraton is complete so store
 // the current theme and language names as the last fully processed ones in
 // the settings and stop.
 if (mQueue.isEmpty()) {
 qDebug() << PRE << "queue is empty  regen finished";
 mSettings->setValue(last_theme_key, hbInstance->theme()->name());
 mSettings->setValue(last_lang_key, QLocale::system().name());
 QString outDir = hbsplash_output_dir();
-mSettings->setValue(last_file_count_key, updateOutputDirContents(outDir));
+// Notify the server and get the number of generated files...
+int fileCount = updateOutputDirContents(outDir);
+// ...but store zero if some file writing failed at some point
+// so there will be a regeneration on next boot at least.
+if (mSaveSplFailed) {
+qWarning() << PRE << "some files not ok, ignoring file count";
+fileCount = 0;
+// Waiting until next boot is not always the best solution so try
+// again a bit later. This has to be limited, though, to prevent
+// continously flooding the system with regenerate requests in case
+// of an unusable drive. So retry only for a limited number of
+// times, if all else fails we will try again on next boot.
+static int retriesLeft = 3;
+if (retriesLeft-- > 0) {
+QTimer::singleShot(60000, this, SLOT(scheduleRegen())); // 1 min
+}
+} else {
+splDeb() << PRE << "all files ok";
+}
+mSettings->setValue(last_file_count_key, fileCount);
 mSettings->setValue(last_output_dir_key, outDir);
 emit finished();
-qDebug() << PRE << "processQueue() over";
+splDeb() << PRE << "processQueue() over";
 return;
 }
 // If a previous splash generation is still in progress or a compositor is
 // working then do nothing.
 if (!lockMainWindow()) {
 mProcessQueuePending = true;
-qDebug() << PRE << "still busy  processQueue() over";
+splDeb() << PRE << "still busy  processQueue() over";
 return;
 }
 try {
 mProcessQueuePending = false;
 mItem = mQueue.dequeue();
 mItemTime.start();
 log("generating splash screen", mItem.mThemeName, mItem.mOrientation);
 ensureMainWindow();
 mMainWindow->setOrientation(mItem.mOrientation, false);
-qDebug() << PRE << "mainwindow init time (ms):" << mItemTime.elapsed();
+splDeb() << PRE << "mainwindow init time (ms):" << mItemTime.elapsed();
 QTime setupTime;
 setupTime.start();
 setupAppSpecificWindow();
-finishWindow();
+splDeb() << PRE << "content setup time (ms):" << setupTime.elapsed();
-qDebug() << PRE << "content setup time(ms):" << setupTime.elapsed();
+// The async call chain goes like this:
-QMetaObject::invokeMethod(this, "processWindow", Qt::QueuedConnection);
+// processQueue -> finishWindow -> processWindow -> processQueue -> ...
+// finishWindow() cannot be called directly from here because that would
+// result in asserts in QGraphicsScene with certain Qt versions.
+NEXT_STAGE(this, finishWindow);
 } catch (const std::bad_alloc &) {
 cleanup();
 }
-qDebug() << PRE << "processQueue() over";
+splDeb() << PRE << "processQueue() over";
 }
 HbMainWindow *HbSplashGenerator::ensureMainWindow()
 {
 if (!mMainWindow) {
 // The FixedVertical flag is used just to disable the sensor-based
 // orientation switching.
 mMainWindow = new HbMainWindow(0, Hb::WindowFlagFixedVertical);
 // Make sure that at least the 1st phase of the delayed
 // construction is done right now.
-HbMainWindowPrivate::d_ptr(mMainWindow)->_q_delayedConstruction();
+HbMainWindowPrivate *mwd = HbMainWindowPrivate::d_ptr(mMainWindow);
+mwd->_q_delayedConstruction();
+mwd->mStatusBar->startClockTimer(); // may not start otherwise as it gets no visibility events
 }
 return mMainWindow;
 }
 void HbSplashGenerator::processWindow()
 {
 // Take the screenshot, remove content, and move on to the next request in the queue.
-log("processWindow()  rendering splash screen", mItem.mThemeName, mItem.mOrientation);
+if (!newRegenPending()) {
-takeScreenshot();
+log("processWindow()  rendering splash screen", mItem.mThemeName, mItem.mOrientation);
-qDebug() << PRE << "total time for screen (ms):" << mItemTime.elapsed();
+takeScreenshot();
+splDeb() << PRE << "total time for screen (ms):" << mItemTime.elapsed();
+}
 QList<HbView *> views = mMainWindow->views();
 foreach(HbView * view, views) {
 mMainWindow->removeView(view);
 delete view;
 }
 clearTranslators();
 unlockMainWindowInternal();
-QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);
+NEXT_STAGE(this, processQueue);
 log("processWindow() over", mItem.mThemeName, mItem.mOrientation);
 }
 void HbSplashGenerator::takeScreenshot()
 {
 // change.
 QImage image = renderView();
 QTime t;
 t.start();
 QString splashFile = splashFileName();
-qDebug() << PRE << "saving to" << splashFile;
+splDeb() << PRE << "saving to" << splashFile;
 if (saveSpl(splashFile, image, mItem.mFlagsToStore)) {
 #if !defined(Q_OS_SYMBIAN) && defined(QT_DEBUG)
 image.save(splashFile + QLatin1String(".png"));
 #endif
 } else {
 qWarning() << PRE << "file write failed for" << splashFile;
-}
+mSaveSplFailed = true;
-qDebug() << PRE << "save time (ms):" << t.elapsed();
+// After setting the fail flag, clear the queue to stop processing
+// further screens because file writes would probably fail anyway.
+// Instead, processQueue() will schedule a retry at a later time.
+mQueue.clear();
+}
+splDeb() << PRE << "save time (ms):" << t.elapsed();
 log("takeScreenshot() over", mItem.mThemeName, mItem.mOrientation);
 } catch (const std::bad_alloc &) {
 cleanup();
 }
 }
 QString HbSplashGenerator::splashFileName()
 {
 QString outDirName = hbsplash_output_dir();
 QDir dir(outDirName);
+#ifdef Q_OS_SYMBIAN
+// Do not use QDir::mkpath() on Symbian. It is not able to create the
+// 'private' directory itself in case it does not exist (which is possible
+// during first boot because splashgen is started relatively early and the
+// eMMC may be totally empty at that point). RFs::MkDirAll() works better in
+// this respect.
+QString nativeOutPath = QDir::toNativeSeparators(outDirName);
+if (!nativeOutPath.endsWith('\\')) {
+nativeOutPath.append('\\');
+}
+TPtrC nativeOutPathDes(static_cast<const TUint16 *>(nativeOutPath.utf16()),
+nativeOutPath.length());
+TInt err = CCoeEnv::Static()->FsSession().MkDirAll(nativeOutPathDes);
+if (err != KErrNone && err != KErrAlreadyExists) {
+qWarning() << PRE << "MkDirAll failed with" << err << "for" << nativeOutPath;
+}
+#else
 if (!dir.exists()) {
-if (!QDir(".").mkdir(outDirName)) {
+if (!QDir(".").mkpath(outDirName)) {
-qWarning() << PRE << "mkdir failed for" << outDirName;
+qWarning() << PRE << "mkpath failed for" << outDirName;
 }
 }
+#endif
 // "splash_<orientation>_<appid>_<screenid>"
 QString splashFile = dir.filePath("splash_");
 splashFile.append(orientationName(mItem.mOrientation));
 if (!mItem.mAppId.isEmpty()) {
 splashFile.append('_');
 f.write((char *) &w, sizeof(quint32));
 f.write((char *) &h, sizeof(quint32));
 f.write((char *) &bpl, sizeof(quint32));
 f.write((char *) &fmt, sizeof(qint32));
 f.write((char *) &extra, sizeof(quint32));
-f.write((const char *) image.bits(), bpl * h);
+#ifdef HB_SPLASH_COMPRESSION
+QTime t;
+t.start();
+QByteArray compData = qCompress((const uchar *) image.bits(), bpl * h);
+quint32 len = compData.size();
+splDeb() << PRE << "compressed" << bpl * h << "to" << len << "in" << t.elapsed() << "ms";
+f.write((char *) &len, sizeof(quint32));
+qint64 wcount = f.write(compData.constData(), len);
+#else
+quint32 len = 0; // 0 compressed length indicates uncompressed data
+f.write((char *) &len, sizeof(quint32));
+len = bpl * h;
+qint64 wcount = f.write((const char *) image.bits(), len);
+#endif
 f.close();
-return true;
+return wcount == len;
 }
 return false;
 }
 void HbSplashGenerator::cleanup()
 }
 HbSplashGenerator::QueueItem::QueueItem()
 : mOrientation(Qt::Vertical),
 mHideBackground(false),
-mFlagsToStore(0)
+mFlagsToStore(0),
+mFirstInRegen(false)
 {
 }
 HbSplashGenerator::QueueItem::QueueItem(const QString &themeName, Qt::Orientation orientation)
 : mThemeName(themeName),
 mOrientation(orientation),
 mHideBackground(false),
-mFlagsToStore(0)
+mFlagsToStore(0),
+mFirstInRegen(false)
 {
 }
 void HbSplashGenerator::addSplashmlItemToQueue(const QueueItem &item)
 {
 QStringList entries = dir.entryList(QStringList() << "*.splashml", QDir::Files);
 foreach(const QString & entry, entries) {
 // Skip if a file with the same name has already been processed from
 // a different location.
 if (processedFileNames.contains(entry)) {
-qDebug() << PRE << "skipping splashml (already found at other location)" << dir.filePath(entry);
+splDeb() << PRE << "skipping splashml (already found at other location)" << dir.filePath(entry);
 continue;
 }
 processedFileNames.insert(entry);
 QString fullName = dir.filePath(entry);
-qDebug() << PRE << "parsing splashml" << fullName;
+splDeb() << PRE << "parsing splashml" << fullName;
 if (mParsedSplashmls.contains(fullName)) {
 QueueItem item(mParsedSplashmls.value(fullName));
 item.mThemeName = themeName;
 item.mOrientation = orientation;
-qDebug() << PRE << "splashml already parsed  queuing request" << item;
+splDeb() << PRE << "splashml already parsed  queuing request" << item;
 addSplashmlItemToQueue(item);
 continue;
 }
 QueueItem item(themeName, orientation);
 bool ok = parseSplashml(fullName, item);
 && !item.mDocmlWidgetName.isEmpty()
 && !item.mDocmlFileName.isEmpty()) {
 // Add the full path to the filename. The docml is supposed to
 // be in the same directory as the splashml.
 item.mDocmlFileName = dir.filePath(item.mDocmlFileName);
-qDebug() << PRE << "queuing request" << item;
+splDeb() << PRE << "queuing request" << item;
 addSplashmlItemToQueue(item);
 mParsedSplashmls.insert(fullName, item);
 } else {
 qWarning() << PRE << "unable to parse" << fullName;
 }
 QObject *CustomDocumentLoader::createObject(const QString &type, const QString &name)
 {
 QObject *obj = HbDocumentLoader::createObject(type, name);
 if (!obj) {
-qDebug() << PRE << "unsupported object" << type << name;
+splDeb() << PRE << "unsupported object" << type << name;
 // Cannot let parsing fail because of unknown custom widgets
 // so provide an empty HbWidget (or HbView if the splashml
 // prefers that).
 if (mItem.mCustomWidgetSubsts.contains(type)) {
 QString preferredType = mItem.mCustomWidgetSubsts.value(type);
 } else if (mItem.mCondSections.contains(lscKey) && mItem.mOrientation == Qt::Horizontal) {
 sections << mItem.mCondSections.value(lscKey);
 }
 }
 sections << mItem.mForcedSections;
-qDebug() << PRE << "loading" << mItem.mDocmlFileName << "common section";
+splDeb() << PRE << "loading" << mItem.mDocmlFileName << "common section";
 bool ok;
 loader.load(mItem.mDocmlFileName, &ok);
 if (ok && !sections.isEmpty()) {
 foreach(const QString & section, sections) {
-qDebug() << PRE << "loading" << mItem.mDocmlFileName << "section" << section;
+splDeb() << PRE << "loading" << mItem.mDocmlFileName << "section" << section;
 loader.load(mItem.mDocmlFileName, section, &ok);
 }
 }
 if (ok) {
 // Apply child widget settings.
 setupNameBasedWidgetProps(loader);
 // Find the root view and add it to the mainwindow.
 QGraphicsWidget *widget = loader.findWidget(mItem.mDocmlWidgetName);
 if (widget) {
-qDebug() << PRE << "widget created from" << mItem;
+splDeb() << PRE << "widget created from" << mItem;
 mMainWindow->addView(widget);
 } else {
 qWarning() << PRE << "widget creation failed from" << mItem;
 }
 } else {
 || (req.mOrientation == QLatin1String("landscape") && mItem.mOrientation != Qt::Horizontal)) {
 continue;
 }
 HbWidget *widget = qobject_cast<HbWidget *>(loader.findWidget(req.mTargetWidgetName));
 if (widget) {
-qDebug() << PRE << "setting background item" << req.mFrameGraphicsName
+splDeb() << PRE << "setting background item" << req.mFrameGraphicsName
 << "for" << req.mTargetWidgetName;
 widget->setBackgroundItem(
 new HbFrameItem(req.mFrameGraphicsName, req.mFrameGraphicsType),
 (int) req.mZValue);
 }
 }
 }
 void HbSplashGenerator::finishWindow()
 {
+QTime prepTime;
+prepTime.start();
 // There must be a view always in order to support view-specific settings.
 if (mMainWindow->views().isEmpty()) {
 mMainWindow->addView(new HbWidget);
 }
 }
 }
 // Hide dynamic content from status bar (clock, indicators).
 setStatusBarElementsVisible(mMainWindow, false);
+splDeb() << PRE << "time spent in finishWindow() (ms):" << prepTime.elapsed();
+// Continue with rendering the graphics view in processWindow().
+NEXT_STAGE(this, processWindow);
 }
 void HbSplashGenerator::setStatusBarElementsVisible(HbMainWindow *mw, bool visible)
 {
 HbMainWindowPrivate *mwd = HbMainWindowPrivate::d_ptr(mw);
 QString fullName = dir.filePath(name + '_' + lang);
 // fullName is not necessarily an existing file, however the translator
 // may still pick up another suitable file based on this name.
 if (translator->load(fullName)) {
 QCoreApplication::installTranslator(translator);
-qDebug() << PRE << "translator installed:" << fullName;
+splDeb() << PRE << "translator installed:" << fullName;
 ok = true;
 break;
 }
 }
 if (ok) {
 {
 // This version is used by the compositors. Besides resetting the flag it
 // also queues a call to processQueue() if needed.
 unlockMainWindowInternal();
 if (mProcessQueuePending) {
-QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);
+NEXT_STAGE(this, processQueue);
 }
 }
+bool HbSplashGenerator::newRegenPending() const
+{
+return mQueue.isEmpty() ? false : mQueue.head().mFirstInRegen;
+}

changeset 34	ed14f46c0e55
parent 7	923ff622b8b9