FCL/sf/mw/hb: comparison src/hbcore/theme/hbthemeclient_symbian

equal deleted inserted replaced

-:4633027730f5
+:e6ad4ef83b23
 * constructor
 */
 HbThemeClientPrivate::HbThemeClientPrivate():
 clientConnected(false)
 {
-if(THEME_SERVER_NAME != HbMemoryUtils::getCleanAppName()) {
+if (THEME_SERVER_NAME != HbMemoryUtils::getCleanAppName()) {
 themelistener = new CHbThemeListenerPrivate(this);
 }
 #ifdef HB_SGIMAGE_ICON
 sgDriverInit = false;
 #endif
+queueCheckInvoker = CIdle::New(CActive::EPriorityLow); // important to set the proper prio here
 }
 /**
 * HbThemeClientPrivate::connectToServer()
 *
 }
 }
 #ifdef HB_SGIMAGE_ICON
 if (!error && !sgDriverInit) {
 error = sgDriver.Open();
-	if (error == KErrNone) {
+if (error == KErrNone) {
 sgDriverInit = true;
 }
 }
 #endif
 return (clientConnected = (KErrNone == error));
 return(TVersion(KThemeServerMajorVersionNumber,
 KThemeServerMinorVersionNumber,
 KThemeServerBuildVersionNumber));
 }
+class QueueEntry : public CActive
+{
+public:
+QueueEntry(HbThemeClientPrivate *tc);
+~QueueEntry();
+void DoCancel();
+void RunL();
+void init(const HbThemeClient::IconReqInfo &reqInfo,
+HbAsyncIconInfoCallback callback,
+void *callbackParam);
+void issueRequest();
+HbThemeClientPrivate *mTc;
+TPckg<HbSharedIconInfo> *mInfoPckg;
+TPckg<TIconParams> *mParamsPckg;
+void *mCallbackParam;
+HbAsyncIconInfoCallback mCallback;
+HbSharedIconInfo mInfo;
+TIconParams mParams;
+TFileName mIconPathBuf;
+};
+// Never call this directly, use scheduleQueueCheck() to have it
+// invoked asynchronously when there is nothing better to do.
+static TInt checkQueue(TAny *param)
+{
+HbThemeClientPrivate *tc = static_cast<HbThemeClientPrivate *>(param);
+// Only one request can be sent a time. The themeserver is single-threaded
+// and has no special async support so it blocks anyway.
+if (tc->reqQueue.isEmpty()) {
+return 0;
+}
+foreach (QueueEntry *e, tc->reqQueue) {
+if (e->IsActive()) {
+return 0;
+}
+}
+tc->reqQueue.head()->issueRequest();
+return 0;
+}
+QueueEntry::QueueEntry(HbThemeClientPrivate *tc)
+: CActive(EPriorityStandard),
+mTc(tc), mInfoPckg(0), mParamsPckg(0), mCallbackParam(0)
+{
+CActiveScheduler::Add(this);
+}
+QueueEntry::~QueueEntry()
+{
+Cancel();
+delete mParamsPckg;
+delete mInfoPckg;
+}
+void QueueEntry::DoCancel()
+{
+// No cancel support on server-side, so complete here. This also means that
+// Cancel() can only be called from the dtor. See cancelGetSharedIconInfo().
+TRequestStatus *rs = &iStatus;
+User::RequestComplete(rs, KErrCancel);
+}
+void QueueEntry::RunL()
+{
+if (iStatus != KErrCancel) {
+mTc->reqQueue.removeOne(this);
+if (iStatus != KErrNone) {
+mInfo.type = INVALID_FORMAT;
+}
+if (!mCallback || !mCallback(mInfo, mCallbackParam)) {
+// Requestor is not interested, may not even exist anymore, so unload.
+HbThemeClient::IconReqInfo reqInfo;
+reqInfo.iconPath = QString::fromUtf16(mParams.fileName.Ptr(), mParams.fileName.Length());
+reqInfo.size = QSizeF(mParams.width, mParams.height);
+reqInfo.aspectRatioMode = (Qt::AspectRatioMode) mParams.aspectRatioMode;
+reqInfo.mode = (QIcon::Mode) mParams.mode;
+reqInfo.mirrored = (bool) mParams.mirrored;
+reqInfo.color = mParams.colorflag ? QColor(mParams.rgba) : QColor();
+reqInfo.renderMode = (HbRenderingMode) mParams.renderMode;
+mTc->unloadIcon(reqInfo);
+}
+mTc->scheduleQueueCheck();
+delete this;
+}
+}
+void QueueEntry::init(const HbThemeClient::IconReqInfo &reqInfo,
+HbAsyncIconInfoCallback callback,
+void *callbackParam)
+{
+mCallback = callback;
+mCallbackParam = callbackParam;
+mInfo.type = INVALID_FORMAT;
+mIconPathBuf = TFileName(reqInfo.iconPath.utf16());
+mParams.fileName = mIconPathBuf;
+mParams.width = reqInfo.size.width();
+mParams.height = reqInfo.size.height();
+mParams.aspectRatioMode = (TUint8) reqInfo.aspectRatioMode;
+mParams.mode = (TUint8) reqInfo.mode;
+mParams.options = (TUint8) reqInfo.options;
+mParams.mirrored = (TBool) reqInfo.mirrored;
+mParams.rgba = (TUint32) reqInfo.color.rgba();
+mParams.colorflag = reqInfo.color.isValid();
+mParams.renderMode = reqInfo.renderMode;
+mInfoPckg = new TPckg<HbSharedIconInfo>(mInfo);
+mParamsPckg = new TPckg<TIconParams>(mParams);
+}
+void QueueEntry::issueRequest()
+{
+TIpcArgs args(mParamsPckg, mInfoPckg);
+mTc->SendReceive(EIconLookup, args, iStatus);
+SetActive();
+}
 /**
 * HbThemeClientPrivate::getSharedIconInfo()
 *
-* Returns the shared icon information
+* Returns the shared icon information, asynchronous version.
 */
-HbSharedIconInfo HbThemeClientPrivate::getSharedIconInfo(const QString &iconPath,
+void HbThemeClientPrivate::getSharedIconInfo(const HbThemeClient::IconReqInfo &reqInfo,
-const QSizeF &size,
+HbAsyncIconInfoCallback callback,
-Qt::AspectRatioMode aspectRatioMode,
+void *callbackParam)
-QIcon::Mode mode,
+{
-bool mirrored,
+if (!clientConnected) {
-HbIconLoader::IconLoaderOptions options,
+HbSharedIconInfo info;
-const QColor &color,
+info.type = INVALID_FORMAT;
-HbRenderingMode renderMode)
+callback(info, callbackParam);
+return;
+}
+QueueEntry *e = new QueueEntry(this);
+e->init(reqInfo, callback, callbackParam);
+reqQueue.enqueue(e);
+scheduleQueueCheck();
+}
+void HbThemeClientPrivate::scheduleQueueCheck()
+{
+if (queueCheckInvoker && !queueCheckInvoker->IsActive()) {
+queueCheckInvoker->Start(TCallBack(checkQueue, this));
+}
+}
+/**
+* HbThemeClientPrivate::cancelGetSharedIconInfo
+*
+* Cancels a previous async getSharedIconInfo request.
+* If callbackParam is 0 then it is ignored and only \a callback is used in the matching.
+* Otherwise both \a callback and \a callbackParam must match.
+*/
+void HbThemeClientPrivate::cancelGetSharedIconInfo(HbAsyncIconInfoCallback callback,
+void *callbackParam)
+{
+for (int i = 0; i < reqQueue.count(); ++i) {
+QueueEntry *e = reqQueue.at(i);
+if (e->mCallback == callback && (!callbackParam || callbackParam == e->mCallbackParam)) {
+if (e->IsActive()) {
+// There is no real cancelation support, the themeserver is busy
+// and is blocked at this point, so just let it go and ignore
+// the future results. Calling Cancel() would potentially result
+// in a stray signal.
+e->mCallback = 0;
+} else {
+delete e;
+reqQueue.removeAt(i--);
+}
+}
+}
+}
+inline TIconParams reqInfoToParams(const HbThemeClient::IconReqInfo &reqInfo)
+{
+TIconParams params;
+params.fileName.Copy(TPtrC(static_cast<const TUint16 *>(reqInfo.iconPath.utf16()),
+reqInfo.iconPath.length()));
+params.width = reqInfo.size.width();
+params.height = reqInfo.size.height();
+params.aspectRatioMode = (TUint8)  reqInfo.aspectRatioMode;
+params.mode = (TUint8) reqInfo.mode;
+params.options = (TUint8) reqInfo.options;
+params.mirrored = (TBool) reqInfo.mirrored;
+params.rgba = (TUint32) reqInfo.color.rgba();
+params.colorflag = reqInfo.color.isValid();
+params.renderMode = reqInfo.renderMode;
+return params;
+}
+/**
+* HbThemeClientPrivate::getSharedIconInfo()
+*
+* Returns the shared icon information, synchronous version.
+*/
+HbSharedIconInfo HbThemeClientPrivate::getSharedIconInfo(const HbThemeClient::IconReqInfo &reqInfo)
 {
 HbSharedIconInfo sharedIconInfo;
 sharedIconInfo.type = INVALID_FORMAT;
-if ( !clientConnected ) {
+if (!clientConnected) {
 return sharedIconInfo;
 }
-TBuf<256> buffer(iconPath.utf16());
 TPckg<HbSharedIconInfo> iconInfo(sharedIconInfo);
+TIconParams params = reqInfoToParams(reqInfo);
-TIconParams params;
-params.fileName = buffer;
-params.width = size.width();
-params.height = size.height();
-params.aspectRatioMode = (TUint8)aspectRatioMode;
-params.mode = (TUint8)mode;
-params.options = (TUint8)options;
-params.mirrored = (TBool)mirrored;
-params.rgba = (TUint32) color.rgba();
-params.colorflag = color.isValid();
-params.renderMode = renderMode;
 TPckg<TIconParams> paramPckg(params);
+TIpcArgs args(&paramPckg, &iconInfo);
-TIpcArgs args(&paramPckg,&iconInfo);
 TInt err = SendReceive(EIconLookup, args);
 if (KErrNone != err) {
-sharedIconInfo.type  = INVALID_FORMAT;
+sharedIconInfo.type = INVALID_FORMAT;
 }
 return sharedIconInfo;
 }
 /**
 * getMultiPartIconInfo
 */
 HbSharedIconInfo HbThemeClientPrivate::getMultiPartIconInfo(
 const QStringList &multiPartIconList,
 const HbMultiPartSizeData &multiPartIconData,
 const QSizeF &size,
 Qt::AspectRatioMode aspectRatioMode,
 }
 TPckg<HbSharedIconInfo> iconInfo(sharedIconInfo);
 TMultiIconSymbParams params;
-TBuf<256> iconId(multiPartIconData.multiPartIconId.utf16());
+TFileName iconId(multiPartIconData.multiPartIconId.utf16());
 params.multiPartIconId.Copy(iconId);
 for (int i = 0; i < multiPartIconList.length(); i++) {
-TBuf<256> pieceIconId(multiPartIconList[i].utf16());
+TFileName pieceIconId(multiPartIconList[i].utf16());
 params.multiPartIconList[i].Copy(pieceIconId);
 }
 int noOfPieces = 1;
 if (multiPartIconData.multiPartIconId.contains("_3PV", Qt::CaseInsensitive)
 || multiPartIconData.multiPartIconId.contains("_3PH", Qt::CaseInsensitive)) {
 if ( !clientConnected ) {
 return 0;
 }
 HbCss::StyleSheet *styleSheet(0);
-TBuf<256> fileDes(fileName.utf16());
+TFileName fileDes(fileName.utf16());
 TBuf<5> layerPriority;
 layerPriority.AppendNum((TInt)priority);
 HbSharedStyleSheetInfo stylesheetInfo;
 TPckg<HbSharedStyleSheetInfo> sharedInfo(stylesheetInfo);
 return 0;
 }
 HbEffectFxmlData *fxmlData = 0;
-TBuf<256> fileDes(filePath.utf16());
+TFileName fileDes(filePath.utf16());
 HbSharedEffectInfo effectInfo;
 TPckg<HbSharedEffectInfo> sharedInfo(effectInfo);
 TIpcArgs args(&fileDes, &sharedInfo);
 #endif
 if ( !clientConnected ) {
 return false;
 }
-TBuf<256> fileDes(filePath.utf16());
+TFileName fileDes(filePath.utf16());
 TInt retVal = KErrGeneral;
 TPckg<TInt> sharedInfo(retVal);
 TIpcArgs args(&fileDes, &sharedInfo);
 return false;
 }
 /**
 * HbThemeClientPrivate::unloadIcon()
-*
+*/
-* unload icon
+void HbThemeClientPrivate::unloadIcon(const HbThemeClient::IconReqInfo &reqInfo)
-*/
+{
-void HbThemeClientPrivate::unloadIcon(const QString &iconPath,
+if (!clientConnected) {
-const QSizeF &size,
-Qt::AspectRatioMode aspectRatioMode,
-QIcon::Mode mode,
-bool mirrored,
-const QColor &color,
-HbRenderingMode renderMode)
-{
-if ( !clientConnected ) {
 return;
 }
-TBuf<256> buffer(iconPath.utf16());
+TIconParams params = reqInfoToParams(reqInfo);
-TIconParams params;
-params.fileName = buffer;
-params.width = size.width();
-params.height = size.height();
-params.aspectRatioMode = (TUint8)aspectRatioMode;
-params.mode = (TUint8)mode;
-params.options = (TUint8)0;
-params.mirrored = (TBool)mirrored;
-params.rgba = (TUint32) color.rgba();
-params.colorflag = color.isValid();
-params.renderMode = (TUint8)renderMode;
 TPckg<TIconParams> paramPckg(params);
-TIpcArgs args(&paramPckg, 0);
+TIpcArgs args(&paramPckg);
 SendReceive(EUnloadIcon, args);
+}
+/**
+* HbThemeClientPrivate::batchUnloadIcon()
+*/
+void HbThemeClientPrivate::batchUnloadIcon(const QVector<HbThemeClient::IconReqInfo> &reqInfos)
+{
+if (!clientConnected) {
+return;
+}
+int idx = 0;
+typedef TIconParams Params[BATCH_SIZE_LIMIT];
+Params paramList;
+for (int i = 0, ie = reqInfos.count(); i != ie; ++i) {
+paramList[idx++] = reqInfoToParams(reqInfos.at(i));
+if (idx == BATCH_SIZE_LIMIT || i == ie - 1) {
+// There may be unused entries in the last batch.
+for (int j = idx; j < BATCH_SIZE_LIMIT; ++j) {
+paramList[j].fileName.Zero();
+}
+idx = 0;
+TPckg<Params> paramsPckg(paramList);
+TIpcArgs args(&paramsPckg);
+SendReceive(EBatchUnloadIcon, args);
+}
+}
 }
 /**
 * HbThemeClientPrivate::unLoadMultiIcon()
 *
 TIconListParams params;
 int noOfPieces = iconPathList.length();
 for (int i = 0; i < noOfPieces; i++) {
 TFileName pieceIconId(iconPathList[i].utf16());
 params.iconList[i].Copy(pieceIconId);
 params.sizeList[i] = sizeList[i];
 }
 params.aspectRatioMode = (TUint8)aspectRatioMode;
 return 0;
 }
 HbWidgetLoader::LayoutDefinition *layoutDef(0);
-TBuf<256> fileDes(fileName.utf16());
+TFileName fileDes(fileName.utf16());
-TBuf<256> layoutDes(layout.utf16());
+TFileName layoutDes(layout.utf16());
-TBuf<256> sectionDes(section.utf16());
+TFileName sectionDes(section.utf16());
 HbSharedWMLInfo widgetmlInfo;
 TPckg<HbSharedWMLInfo> wmlInfo(widgetmlInfo);
 TIpcArgs args(&fileDes,&layoutDes,&sectionDes,&wmlInfo);
 /**
 * Destructor
 */
 HbThemeClientPrivate::~HbThemeClientPrivate()
 {
+// Make a copy and destroy the elements after emptying the real queue so
+// checkQueue() can safely be called during the destruction of the elements.
+QueueType qc = reqQueue;
+reqQueue.clear();
+foreach (QueueEntry *e, qc) {
+delete e;
+}
+delete queueCheckInvoker; // destroy only when no QueueEntries are alive
 RSessionBase::Close();
 #ifdef HB_SGIMAGE_ICON
 if (sgDriverInit) {
 sgDriver.Close();
 sgDriverInit = false;
 }
 #endif
 delete themelistener;
 }
 /**
 * StartServer

changeset 23	e6ad4ef83b23
parent 21	4633027730f5
child 28	b7da29130b0e