1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "hbmeasuretest.h"

    19 

    20 #include <QGridLayout>

    21 #include <HbLabel>

    22 #include <HbPushButton>

    23 #include <QCoreApplication>

    24 #include <QSignalMapper>

    25 #include <QVariant>

    26 #include <QList>

    27 #include <QVariantHash>

    28 #include <HbComboBox>

    29 #include <QBrush>

    30 #include <QPalette>

    31 #include <QGraphicsGridLayout>

    32 #include <QTimer>

    33 #include <QFile>

    34 #include <QTextStream>

    35 #include <e32std.h>

    36 #include <HbInstance>

    37 #include <qservicemanager.h>

    38 #include <HbScrollArea>

    39 #include <afactivitystorage.h>

    40 #include <afactivation.h>

    41 #include "afstorageglobals.h"

    42 #include <HbCheckBox>

    43 

    44 

    45 QTM_USE_NAMESPACE

    46 

    47 MeasureTest::MeasureTest(QGraphicsItem *parent) : HbView(parent), mByteArray(NULL)

    48 

    49 {

    50     mFile = new QFile("c:\\actbenchmark.txt");    

    51     mFile->open(QIODevice::Append | QIODevice::Text);

    52     mStream = new QTextStream(mFile);

    53     

    54     mThumbwait = 0;

    55     mThumbnull = 0;

    56     mThumbcurrent = 0;

    57     QServiceManager serviceManager;

    58     serviceManager.addService(":/activityserviceplugin.xml");

    59     

    60     mActivityManager = serviceManager.loadInterface("com.nokia.qt.activities.ActivityManager");

    61     if (!mActivityManager) {

    62         qFatal("Cannot initialize critical com.nokia.qt.activities.ActivityManager service.");

    63         }

    64         

    65     mThumbwait = 0;

    66     mThumbnull = 0;

    67     mThumbcurrent = 0;

    68     mActivityStorage = new AfActivityStorage;

    69     mActivation = new AfActivation;

    70         

    71     HbWidget* widget = new HbWidget;

    72     HbScrollArea* scrollArea = new HbScrollArea; 

    73 	

    74     mResultLabel = new HbLabel();

    75     mItemLabel = new HbLabel();

    76     mTimesLabel = new HbLabel("Times");

    77     mBytesLabel = new HbLabel("Bytes");

    78     mPixmapLabel = new HbLabel("Pixmap");  	  

    79     mSizeLabel = new HbLabel("Size(WxH)");

    80 

    81     mPixmap = new QPixmap(":/images/wolf.bmp");

    82     mEmptyPixmap = new QPixmap();

    83 

    84 

    85     mTimesCombo = new HbComboBox();

    86     mLengthCombo = new HbComboBox();

    87     mPixmapCombo = new HbComboBox();

    88     mWidthCombo = new HbComboBox();

    89     mHeightCombo = new HbComboBox();

    90 

    91     mTimesCombo->addItem("1");

    92     mTimesCombo->addItem("2");	

    93     mTimesCombo->addItem("4");

    94     mTimesCombo->addItem("5");

    95     mTimesCombo->addItem("10");

    96     mTimesCombo->addItem("20");

    97     mTimesCombo->addItem("40");

    98     mTimesCombo->addItem("60");

    99 

   100     QVariant variant;

   101     variant = 10;

   102     mLengthCombo->addItem("10 B", variant);

   103     variant = 100;

   104     mLengthCombo->addItem("100 B", variant);

   105     variant = 1024;

   106     mLengthCombo->addItem("1 KB", variant);

   107     variant = 10240;

   108     mLengthCombo->addItem("10 KB", variant);

   109     variant = 102400;

   110     mLengthCombo->addItem("100 KB", variant);

   111     variant = 1024*1024;

   112     mLengthCombo->addItem("1 MB", variant);

   113     

   114     mWidthCombo->addItem("360");

   115     mWidthCombo->addItem("180");

   116     mWidthCombo->addItem("128");

   117     mWidthCombo->addItem("90");

   118     

   119     mHeightCombo->addItem("640");

   120     mHeightCombo->addItem("320");

   121     mHeightCombo->addItem("160");

   122     mHeightCombo->addItem("128");

   123     

   124 

   125     mPixmapCombo->addItem("no");

   126     mPixmapCombo->addItem("yes");

   127     mPixmapCombo->addItem("grab");

   128 

   129     mSaveButton = new HbPushButton("Save activities");

   130     mGetButton = new HbPushButton("Get activities");

   131     mDelButton = new HbPushButton("Delete activities");

   132     mGetDataButton = new HbPushButton("Get activities data");

   133     mUpdateButton = new HbPushButton("Reserved");

   134     mThumbButton = new HbPushButton("Get act with thumb");

   135     mGetDataTimesButton = new HbPushButton("Get data times");

   136     mSaveTimesButton = new HbPushButton("Add act times");

   137     mSave10TimesButton = new HbPushButton("Add 10 act times");;

   138 

   139     mSaveDekCheckBox = new HbCheckBox("Delete before Save");

   140     mSaveDekCheckBox->setCheckState(Qt::Checked);

   141 

   142     mLayout  = new QGraphicsGridLayout();

   143     mLayout->addItem(mSizeLabel, 2, 0, 1, 2);

   144     mLayout->addItem(mWidthCombo, 2, 2, 1, 2);

   145     mLayout->addItem(mHeightCombo, 2, 4, 1, 2);

   146     mLayout->addItem(mTimesLabel, 3, 0, 1, 2);

   147     mLayout->addItem(mBytesLabel, 3, 2, 1, 2);

   148     mLayout->addItem(mPixmapLabel, 3, 4, 1, 2);

   149     mLayout->addItem(mTimesCombo, 4, 0, 1, 2);

   150     mLayout->addItem(mLengthCombo, 4, 2, 1, 2);

   151     mLayout->addItem(mPixmapCombo, 4, 4, 1, 2);

   152     mLayout->addItem(mSaveButton, 5, 0, 1, 6);

   153     mLayout->addItem(mGetButton, 6, 0, 1, 6);

   154     mLayout->addItem(mDelButton, 7, 0, 1, 6);

   155     mLayout->addItem(mGetDataButton, 8, 0, 1, 6);

   156     mLayout->addItem(mUpdateButton, 9, 0, 1, 6);

   157     mLayout->addItem(mThumbButton, 10, 0, 1, 6);

   158     mLayout->addItem(mSaveTimesButton, 11, 0, 1, 6);

   159     mLayout->addItem(mSave10TimesButton, 12, 0, 1, 6);

   160     mLayout->addItem(mGetDataTimesButton, 13, 0, 1, 6);

   161     mLayout->addItem(mSaveDekCheckBox, 14, 0, 1, 6);

   162     widget->setLayout(mLayout);

   163     

   164     scrollArea->setContentWidget(widget);

   165     scrollArea->setScrollDirections(Qt::Vertical);

   166     scrollArea->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

   167     connect(mSaveButton, SIGNAL(released()), this, SLOT(saveActivity()));

   168     connect(mGetButton, SIGNAL(released()), this, SLOT(getActivity()));

   169     connect(mDelButton, SIGNAL(released()), this, SLOT(deleteActivity()));

   170     connect(mGetDataButton, SIGNAL(released()), this, SLOT(getActivityData()));

   171     connect(mUpdateButton, SIGNAL(released()), this, SLOT(updateActivity()));

   172     connect(mThumbButton, SIGNAL(released()), this, SLOT(getActivityThumb()));

   173     connect(mGetDataTimesButton, SIGNAL(released()), this, SLOT(getTimesActivityData()));

   174     connect(mSaveTimesButton, SIGNAL(released()), this, SLOT(saveTimes()));

   175     connect(mSave10TimesButton, SIGNAL(released()), this, SLOT(save10actTimes()));

   176 

   177     QGraphicsGridLayout* mainLayout = new QGraphicsGridLayout;

   178     mainLayout->addItem(mResultLabel, 0, 0, 1, 6);

   179     mainLayout->addItem(mItemLabel, 1, 0, 1, 6);

   180     mainLayout->addItem(scrollArea, 2, 0, 1, 6);    

   181     setLayout(mainLayout);

   182 

   183 }

   184 

   185 MeasureTest::~MeasureTest()

   186 {

   187     delete mFile;

   188     delete mStream;

   189     delete mEmptyPixmap;

   190     delete mPixmap;    

   191     delete mActivityManager;

   192     delete mActivityStorage;

   193     delete mActivation;

   194 }

   195 

   196 

   197 void MeasureTest::Before()

   198 {

   199     TTime time;

   200     time.HomeTime();

   201     iBefore = time.Int64();

   202 }

   203 

   204 void MeasureTest::After()

   205 {

   206     TTime time;

   207     time.HomeTime();

   208     iAfter = time.Int64();

   209 }

   210 

   211 void MeasureTest::Result()

   212 {

   213     TInt64 res(0);

   214     res = iAfter-iBefore;

   215     res = res/1000;

   216     iResult = res;

   217 }

   218 

   219 void  MeasureTest::deleteActivity()

   220 {

   221     QStringList activities = mActivityStorage->allActivities();    

   222     QString name;

   223     Before();

   224     bool ok = false;

   225     for (int i=0; i<activities.count(); i++) {

   226         ok = mActivityStorage->removeActivity(activities.at(i));        

   227         if (!ok) {

   228             break;

   229         }

   230     }

   231     After();

   232     Result();

   233     

   234     mItemMessage.clear();

   235     mResultMessage.clear();

   236 

   237     if (!ok) {

   238         mItemMessage = (tr("invoke error"));

   239         mResultMessage = (tr("invoke error"));

   240     } else {

   241         mItemMessage = (tr("items: %1")).arg(activities.count());

   242         mResultMessage = (tr("time: %1 ms")).arg(iResult);

   243     }

   244     mItemLabel->setPlainText(mItemMessage);

   245     mResultLabel->setPlainText(mResultMessage);

   246 }

   247 

   248 void  MeasureTest::getActivity()

   249 {

   250     QStringList activities;

   251     Before();

   252     activities = mActivityStorage->allActivities(); 

   253     After();

   254     Result();

   255     int count = activities.count();

   256     mItemMessage.clear();

   257     mResultMessage.clear();

   258 

   259     mItemMessage = (tr("items: %1")).arg(count);

   260     mResultMessage = (tr("time: %1 ms")).arg(iResult);

   261 

   262     mItemLabel->setPlainText(mItemMessage);

   263     mResultLabel->setPlainText(mResultMessage);

   264 }

   265 

   266 void  MeasureTest::getActivityThumb()

   267 {

   268     disconnect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );

   269     connect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );

   270     mThumbwait = 0;

   271     mThumbnull = 0;

   272     mThumbcurrent = 0;

   273     bool ok = false;

   274     QStringList activities;

   275     Before();

   276     activities = mActivityStorage->allActivities();   

   277     mThumbwait = activities.count();

   278     int width = mWidthCombo->currentText().toInt();

   279     int height = mHeightCombo->currentText().toInt();

   280     QSize pixSize(width, height);

   281     for ( int i=0; i<activities.count(); i++)

   282         {

   283         QString pixfile = mActivityStorage->activityMetaData(activities.at(i)).value(ActivityScreenshotKeyword).toString();

   284         ok = QMetaObject::invokeMethod(mActivityManager, "getThumbnail", Q_ARG(QSize, pixSize), Q_ARG(QString, pixfile), Q_ARG(void*, NULL));        

   285         if ( !ok )

   286             {

   287             break;

   288             }        

   289         }

   290 

   291     int count = activities.count();

   292     mItemMessage.clear();

   293     mResultMessage.clear();

   294     if (!ok) {

   295         mItemMessage = (tr("invoke error"));

   296         mResultMessage = (tr("invoke error"));

   297         mItemLabel->setPlainText(mItemMessage);

   298         mResultLabel->setPlainText(mResultMessage);

   299     } else {

   300         

   301     }    

   302 }

   303 

   304 void MeasureTest::saveActivity()

   305 {

   306     int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();

   307     delete mByteArray;

   308     mByteArray = NULL;

   309     mByteArray = new QByteArray(bytes, 'a');

   310     QVariant variant;

   311     variant = *mByteArray;

   312     QPixmap *pixmap = NULL;

   313     QPixmap screenshot;

   314     if (mPixmapCombo->currentText() == "yes") {

   315         pixmap = mPixmap;

   316     }

   317     else if ( mPixmapCombo->currentText() == "grab" )

   318     {

   319         HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

   320         screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

   321         pixmap = &screenshot;

   322     }

   323     else

   324     {

   325         pixmap = mEmptyPixmap;

   326     }

   327     QVariantHash metadata;

   328     metadata.insert(ActivityScreenshotKeyword, *pixmap);

   329     int times = 0;

   330     times = mTimesCombo->currentText().toInt();

   331     bool ok = false;    

   332     Before();

   333     for (int i=0; i<times; i++) {

   334         QString name;

   335         name.setNum(i);

   336         ok = mActivityStorage->saveActivity(name, variant, metadata);

   337         if (!ok) {

   338             break;

   339         }

   340     }

   341     After();

   342     Result();

   343     mItemMessage.clear();

   344     mResultMessage.clear();

   345     if (!ok) {

   346         mItemMessage = (tr("invoke error"));

   347         mResultMessage = (tr("invoke error"));

   348     } else {

   349         mResultMessage = (tr("time: %1 ms")).arg(iResult);

   350     }

   351     mItemLabel->setPlainText(mItemMessage);

   352     mResultLabel->setPlainText(mResultMessage);

   353 }

   354 

   355 void MeasureTest::updateActivity()

   356 {

   357  

   358 }

   359 

   360 void MeasureTest::getActivityData()

   361 {

   362     QStringList activities = mActivityStorage->allActivities();    

   363 

   364     QString name;

   365     QVariant data;

   366     Before();

   367     for (int i=0; i<activities.count(); i++) {

   368         data = mActivityStorage->activityData(activities.at(i));

   369     }

   370     After();

   371     Result();

   372 

   373     mItemMessage.clear();

   374     mResultMessage.clear();

   375 

   376     mItemMessage = (tr("items: %1")).arg(activities.count());

   377     mResultMessage = (tr("time: %1 ms")).arg(iResult);

   378 

   379     mItemLabel->setPlainText(mItemMessage);

   380     mResultLabel->setPlainText(mResultMessage);

   381 }

   382 

   383 void MeasureTest::thumbnailReady(QPixmap pix, void * ptr)

   384     {

   385     if ( pix.isNull() )

   386         {

   387         mThumbnull++;

   388         }    

   389     mThumbcurrent++;

   390     mItemMessage = (tr("items: %1 from %2, but null %3")).arg(mThumbcurrent).arg(mThumbwait).arg(mThumbnull);

   391     mItemLabel->setPlainText(mItemMessage);

   392     mResultMessage = "";

   393     mResultLabel->setPlainText(mResultMessage);

   394     if (mThumbcurrent == mThumbwait)

   395         {

   396         After();

   397         Result();

   398         disconnect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );

   399         mResultMessage = (tr("time: %1 ms")).arg(iResult);

   400         mResultLabel->setPlainText(mResultMessage);

   401         }

   402     }

   403 void MeasureTest::saveTimes()

   404 {

   405     *mStream<<"save Times\n";

   406     QList<int> trymeasure;

   407     int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();

   408     delete mByteArray;

   409     mByteArray = NULL;

   410     mByteArray = new QByteArray(bytes, 'a');

   411     QVariant variant;

   412     variant = *mByteArray;

   413     QPixmap *pixmap = NULL;

   414     QPixmap screenshot;

   415     if (mPixmapCombo->currentText() == "yes") {

   416         pixmap = mPixmap;

   417     }

   418     else if ( mPixmapCombo->currentText() == "grab" )

   419     {

   420         HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

   421         screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

   422         pixmap = &screenshot;

   423     }

   424     else

   425     {

   426         pixmap = mEmptyPixmap;

   427     }

   428     QVariantHash metadata;

   429     metadata.insert(ActivityScreenshotKeyword, *pixmap);

   430     int times = 0;

   431     times = mTimesCombo->currentText().toInt();

   432     bool ok = false;    

   433     QString name("0");

   434     bool delBefore = mSaveDekCheckBox->checkState() == Qt::Checked ? true : false;

   435     User::After(2000000); //2s

   436     for (int i=0; i<times; i++) {

   437         Before();

   438         ok = mActivityStorage->saveActivity(name, variant, metadata);

   439         After();

   440         Result();

   441         if (!ok) {

   442               break;

   443           }

   444         trymeasure.append(iResult);

   445         if (delBefore) {

   446             ok = mActivityStorage->removeActivity(name);   

   447             if (!ok) {

   448                 break;

   449             }

   450         }

   451         User::After(2000000); //2s

   452     }

   453 

   454     mItemMessage.clear();

   455     mResultMessage.clear();

   456     if (!ok) {

   457         mItemMessage = (tr("invoke error"));

   458         mResultMessage = (tr("invoke error"));

   459         *mStream<<"error\n";

   460     } else {

   461         int averageint = average(trymeasure);

   462         mResultMessage = (tr("time: %1 ms")).arg(averageint);

   463         writeResults(trymeasure, averageint);

   464     }

   465     mStream->flush();

   466     mItemLabel->setPlainText(mItemMessage);

   467     mResultLabel->setPlainText(mResultMessage);    

   468 }

   469 

   470 void MeasureTest::save10actTimes()

   471 {

   472     *mStream<<"save 10 act Times\n";

   473     QList<int> trymeasure;

   474     int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();

   475     delete mByteArray;

   476     mByteArray = NULL;

   477     mByteArray = new QByteArray(bytes, 'a');

   478     QVariant variant;

   479     variant = *mByteArray;

   480     QPixmap *pixmap = NULL;

   481     QPixmap screenshot;

   482     bool delBefore = mSaveDekCheckBox->checkState() == Qt::Checked ? true : false;

   483     if (mPixmapCombo->currentText() == "yes") {

   484         pixmap = mPixmap;

   485     }

   486     else if ( mPixmapCombo->currentText() == "grab" )

   487     {

   488         HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

   489         screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

   490         pixmap = &screenshot;

   491     }

   492     else

   493     {

   494         pixmap = mEmptyPixmap;

   495     }

   496     QVariantHash metadata;

   497     metadata.insert(ActivityScreenshotKeyword, *pixmap);

   498     int times = 0;

   499     times = mTimesCombo->currentText().toInt();

   500     bool ok = false;

   501     QString name;

   502     User::After(2000000); //2s

   503     for(int i=0; i<times; i++) {

   504         Before();

   505         for (int i=0; i<10; i++) {

   506             

   507             name.setNum(i);

   508             ok = mActivityStorage->saveActivity(name, variant, metadata);

   509             if (!ok) {

   510                 break;

   511             }            

   512         }

   513         After();

   514         Result();

   515         trymeasure.append(iResult);

   516         

   517         QStringList activities = mActivityStorage->allActivities();      

   518     

   519         if (delBefore) {

   520             for (int i=0; i<activities.count(); i++) {

   521                 ok = mActivityStorage->removeActivity(activities.at(i));    

   522                 if (!ok) {

   523                     break;

   524                 }

   525             }

   526         }

   527         User::After(2000000); //2s        

   528 

   529     }        

   530     mItemMessage.clear();

   531     mResultMessage.clear();

   532     if (!ok) {

   533         mItemMessage = (tr("invoke error"));

   534         mResultMessage = (tr("invoke error"));

   535         *mStream<<"error\n";

   536     } else {

   537         int averageint = average(trymeasure);

   538         mResultMessage = (tr("time: %1 ms")).arg(averageint);

   539         writeResults(trymeasure, averageint);

   540     }

   541     mStream->flush();

   542     mItemLabel->setPlainText(mItemMessage);

   543     mResultLabel->setPlainText(mResultMessage);    

   544     

   545 }

   546 

   547 void MeasureTest::getTimesActivityData()

   548 {

   549     int times = 0;

   550     times = mTimesCombo->currentText().toInt();

   551     *mStream<<"get data Times\n";

   552     QList<int> trymeasure;

   553     

   554     QStringList activities = mActivityStorage->allActivities();  

   555     User::After(2000000); //2s

   556     QString name;

   557     QVariant data;        

   558     for(int i=0; i<times; i++) {

   559         Before();

   560         for (int i=0; i<activities.count(); i++) {

   561             data = mActivityStorage->activityData(activities.at(i));

   562         }

   563         After();

   564         Result();

   565         trymeasure.append(iResult);

   566         User::After(2000000); //2s

   567     }

   568     mItemMessage.clear();

   569     mResultMessage.clear();

   570 

   571 

   572     int averageint = average(trymeasure);

   573     mResultMessage = (tr("time: %1 ms")).arg(averageint);

   574     writeResults(trymeasure, averageint);

   575     

   576     mStream->flush();

   577     mItemLabel->setPlainText(mItemMessage);

   578     mResultLabel->setPlainText(mResultMessage);

   579 

   580 }

   581 

   582 int MeasureTest::average(const QList<int>& list)

   583 {

   584     int count = list.count();

   585     int sum=0;

   586     for(int i=0; i<count; i++) {

   587         sum += list.at(i);

   588     }

   589     sum = (sum+0.5)/count;

   590     return sum;

   591 }

   592 

   593 int MeasureTest::writeResults(const QList<int>& list, int average)

   594 {

   595     for(int i=0; i<list.count(); i++){

   596         *mStream<<"|  ";

   597         *mStream<<list.at(i);

   598         *mStream<<"  |\n";

   599     }

   600     *mStream<<"|  ";

   601     *mStream<<average;

   602     *mStream<<"  |\n";

   603 }