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 

    40 const char ActivityApplicationKeyword [] = ":ApplicationId";

    41 const char ActivityActivityKeyword [] = ":ActivityName";

    42 const char ActivityScreenshotKeyword [] = "screenshot";

    43 

    44 QTM_USE_NAMESPACE

    45 

    46 MeasureTest::MeasureTest(QGraphicsItem *parent) : HbView(parent), mActivityClient(NULL), mByteArray(NULL)

    47 

    48 {

    49     mFile = new QFile("c:\\measuretest.txt");    

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

    51     mStream = new QTextStream(mFile);

    52     

    53     mThumbwait = 0;

    54     mThumbnull = 0;

    55     mThumbcurrent = 0;

    56     QServiceManager serviceManager;

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

    58     mActivityClient = serviceManager.loadInterface("com.nokia.qt.activities.ActivityClient");

    59     if (!mActivityClient) {

    60         qFatal("Cannot initialize critical com.nokia.qt.activities.ActivityClient service.");

    61     }

    62 

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

    64     if (!mActivityManager) {

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

    66     }

    67     

    68     HbWidget* widget = new HbWidget;

    69     HbScrollArea* scrollArea = new HbScrollArea; 

    70     

    71     mResultLabel = new HbLabel();

    72     mItemLabel = new HbLabel();

    73     mTimesLabel = new HbLabel("Times");

    74     mBytesLabel = new HbLabel("Bytes");

    75     mPixmapLabel = new HbLabel("Pixmap");  	  

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

    77 

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

    79     mEmptyPixmap = new QPixmap();

    80 

    81 

    82     mTimesCombo = new HbComboBox();

    83     mLengthCombo = new HbComboBox();

    84     mPixmapCombo = new HbComboBox();

    85     mWidthCombo = new HbComboBox();

    86     mHeightCombo = new HbComboBox();

    87 

    88     mTimesCombo->addItem("1");

    89     mTimesCombo->addItem("2");	

    90     mTimesCombo->addItem("4");

    91     mTimesCombo->addItem("5");

    92     mTimesCombo->addItem("10");

    93     mTimesCombo->addItem("20");

    94     mTimesCombo->addItem("40");

    95     mTimesCombo->addItem("60");

    96 

    97     QVariant variant;

    98     variant = 10;

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

   100     variant = 100;

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

   102     variant = 1024;

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

   104     variant = 10240;

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

   106     variant = 102400;

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

   108     variant = 1024*1024;

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

   110     

   111     mWidthCombo->addItem("360");

   112     mWidthCombo->addItem("180");

   113     mWidthCombo->addItem("128");

   114     mWidthCombo->addItem("90");

   115     

   116     mHeightCombo->addItem("640");

   117     mHeightCombo->addItem("320");

   118     mHeightCombo->addItem("160");

   119     mHeightCombo->addItem("128");

   120     

   121 

   122     mPixmapCombo->addItem("no");

   123     mPixmapCombo->addItem("yes");

   124     mPixmapCombo->addItem("grab");

   125 

   126     mSaveButton = new HbPushButton("Add activities");

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

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

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

   130     mUpdateButton = new HbPushButton("Update activities");

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

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

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

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

   135 

   136     mLayout  = new QGraphicsGridLayout();

   137     mLayout->addItem(mResultLabel, 0, 0, 1, 6);

   138     mLayout->addItem(mItemLabel, 1, 0, 1, 6);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   157     widget->setLayout(mLayout);

   158     

   159     scrollArea->setContentWidget(widget);

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

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

   162     

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

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

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

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

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

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

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

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

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

   172 

   173     QGraphicsGridLayout* mainLayout = new QGraphicsGridLayout;

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

   175     setLayout(mainLayout);

   176 

   177 }

   178 

   179 MeasureTest::~MeasureTest()

   180 {

   181     delete mFile;

   182     delete mEmptyPixmap;

   183     delete mPixmap;

   184     delete mActivityClient;

   185     delete mActivityManager;

   186 }

   187 

   188 

   189 void MeasureTest::Before()

   190 {

   191     TTime time;

   192     time.HomeTime();

   193     iBefore = time.Int64();

   194 }

   195 

   196 void MeasureTest::After()

   197 {

   198     TTime time;

   199     time.HomeTime();

   200     iAfter = time.Int64();

   201 }

   202 

   203 void MeasureTest::Result()

   204 {

   205     TInt64 res(0);

   206     res = iAfter-iBefore;

   207     res = res/1000;

   208     iResult = res;

   209 }

   210 

   211 void  MeasureTest::deleteActivity()

   212 {

   213     QList<QVariantHash> activities;

   214     bool ok  = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

   215     bool retok = false;

   216 

   217     if (ok) {

   218         QString name;

   219         Before();

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

   221             name = activities.at(i).value(":ActivityName").toString();

   222             ok = QMetaObject::invokeMethod(mActivityClient, "removeActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name));

   223             if (!ok || !retok) {

   224                 break;

   225             }

   226         }

   227         After();

   228         Result();

   229     }

   230     mItemMessage.clear();

   231     mResultMessage.clear();

   232 

   233     if (!ok || !retok) {

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

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

   236     } else {

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

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

   239     }

   240     mItemLabel->setPlainText(mItemMessage);

   241     mResultLabel->setPlainText(mResultMessage);

   242 }

   243 

   244 void  MeasureTest::getActivity()

   245 {

   246     bool ok = false;

   247     QList<QVariantHash> activities;

   248     Before();

   249     ok = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

   250     After();

   251     Result();

   252     int count = activities.count();

   253     mItemMessage.clear();

   254     mResultMessage.clear();

   255     if (!ok) {

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

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

   258     } else {

   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     QList<QVariantHash> activities;

   275     Before();

   276     ok = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

   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 app = activities.at(i).value(ActivityApplicationKeyword);

   284         //QString act = activities.at(i).value(ActivityActivityKeyword);

   285         QString pixfile = activities.at(i).value(ActivityScreenshotKeyword).toString();

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

   287         if ( !ok )

   288             {

   289             break;

   290             }        

   291         }

   292 

   293     int count = activities.count();

   294     mItemMessage.clear();

   295     mResultMessage.clear();

   296     if (!ok) {

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

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

   299         mItemLabel->setPlainText(mItemMessage);

   300         mResultLabel->setPlainText(mResultMessage);

   301     } else {

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

   303     }

   304 

   305     

   306 }

   307 

   308 void MeasureTest::saveActivity()

   309 {

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

   311     delete mByteArray;

   312     mByteArray = NULL;

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

   314     QVariant variant;

   315     variant = *mByteArray;

   316     QPixmap *pixmap = NULL;

   317     QPixmap screenshot;

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

   319         pixmap = mPixmap;

   320     }

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

   322     {

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

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

   325         pixmap = &screenshot;

   326     }

   327     else

   328     {

   329         pixmap = mEmptyPixmap;

   330     }

   331     QVariantHash metadata;

   332     metadata.insert("screenshot", *pixmap);

   333     int times = 0;

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

   335     bool ok = false;

   336     bool retok = false;

   337     Before();

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

   339         QString name;

   340         name.setNum(i);

   341         ok = QMetaObject::invokeMethod(mActivityClient, "addActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name), Q_ARG(QVariant, variant), Q_ARG(QVariantHash, metadata));

   342         if (!ok || !retok) {

   343             break;

   344         }

   345     }

   346     After();

   347     Result();

   348     mItemMessage.clear();

   349     mResultMessage.clear();

   350     if (!ok || !retok) {

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

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

   353     } else {

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

   355     }

   356     mItemLabel->setPlainText(mItemMessage);

   357     mResultLabel->setPlainText(mResultMessage);

   358 }

   359 

   360 void MeasureTest::updateActivity()

   361 {

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

   363     delete mByteArray;

   364     mByteArray = NULL;

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

   366     QVariant variant;

   367     variant = *mByteArray;

   368     QPixmap *pixmap = NULL;

   369     QPixmap screenshot;

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

   371         pixmap = mPixmap;

   372     }

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

   374     {

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

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

   377         pixmap = &screenshot;

   378     }

   379     else

   380     {

   381         pixmap = mEmptyPixmap;

   382     }

   383     QVariantHash metadata;

   384     metadata.insert("screenshot", *pixmap);

   385     int times = 0;

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

   387     bool ok = false;

   388     bool retok = false;

   389     Before();

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

   391         QString name;

   392         name.setNum(i);

   393         ok = QMetaObject::invokeMethod(mActivityClient, "updateActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name), Q_ARG(QVariant, variant), Q_ARG(QVariantHash, metadata));

   394         if (!ok || !retok) {

   395             break;

   396         }

   397     }

   398     After();

   399     Result();

   400     mItemMessage.clear();

   401     mResultMessage.clear();

   402     if (!ok || !retok) {

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

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

   405     } else {

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

   407     }

   408     mItemLabel->setPlainText(mItemMessage);

   409     mResultLabel->setPlainText(mResultMessage);

   410 }

   411 

   412 void MeasureTest::getActivityData()

   413 {

   414     QList<QVariantHash> activities;

   415     bool ok  = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

   416 

   417     if (ok) {

   418         QString name;

   419         QVariant data;

   420         Before();

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

   422             name = activities.at(i).value(":ActivityName").toString();

   423             ok = QMetaObject::invokeMethod(mActivityClient, "activityData", Q_RETURN_ARG(QVariant, data), Q_ARG(QString, name));

   424             if (!ok) {

   425                 break;

   426             }

   427         }

   428         After();

   429         Result();

   430     }

   431     mItemMessage.clear();

   432     mResultMessage.clear();

   433 

   434     if (!ok) {

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

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

   437     } else {

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

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

   440     }

   441     mItemLabel->setPlainText(mItemMessage);

   442     mResultLabel->setPlainText(mResultMessage);

   443 }

   444 

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

   446     {

   447     if ( pix.isNull() )

   448         {

   449         mThumbnull++;

   450         }    

   451     mThumbcurrent++;

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

   453     mItemLabel->setPlainText(mItemMessage);

   454     mResultMessage = "";

   455     mResultLabel->setPlainText(mResultMessage);

   456     if (mThumbcurrent == mThumbwait)

   457         {

   458         After();

   459         Result();

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

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

   462         mResultLabel->setPlainText(mResultMessage);

   463         }

   464     }

   465 

   466 void MeasureTest::saveTimes()

   467 {

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

   469     QList<int> trymeasure;

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

   471     delete mByteArray;

   472     mByteArray = NULL;

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

   474     QVariant variant;

   475     variant = *mByteArray;

   476     QPixmap *pixmap = NULL;

   477     QPixmap screenshot;

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

   479         pixmap = mPixmap;

   480     }

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

   482     {

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

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

   485         pixmap = &screenshot;

   486     }

   487     else

   488     {

   489         pixmap = mEmptyPixmap;

   490     }

   491     QVariantHash metadata;

   492     metadata.insert("screenshot", *pixmap);

   493     int times = 0;

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

   495     bool ok = false;

   496     bool retok = false;

   497     QString name("0");

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

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

   500         Before();

   501         ok = QMetaObject::invokeMethod(mActivityClient, "addActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name), Q_ARG(QVariant, variant), Q_ARG(QVariantHash, metadata));

   502         After();

   503         Result();

   504         if (!ok || !retok) {

   505               break;

   506           }

   507         trymeasure.append(iResult);

   508         ok = QMetaObject::invokeMethod(mActivityClient, "removeActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name));        

   509         if (!ok || !retok) {

   510             break;

   511         }

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

   513     }

   514 

   515     mItemMessage.clear();

   516     mResultMessage.clear();

   517     if (!ok || !retok) {

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

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

   520         *mStream<<"error\n";

   521     } else {

   522         int averageint = average(trymeasure);

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

   524         writeResults(trymeasure, averageint);

   525     }

   526     mStream->flush();

   527     mItemLabel->setPlainText(mItemMessage);

   528     mResultLabel->setPlainText(mResultMessage);    

   529 }

   530 

   531 void MeasureTest::save10actTimes()

   532 {

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

   534     QList<int> trymeasure;

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

   536     delete mByteArray;

   537     mByteArray = NULL;

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

   539     QVariant variant;

   540     variant = *mByteArray;

   541     QPixmap *pixmap = NULL;

   542     QPixmap screenshot;

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

   544         pixmap = mPixmap;

   545     }

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

   547     {

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

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

   550         pixmap = &screenshot;

   551     }

   552     else

   553     {

   554         pixmap = mEmptyPixmap;

   555     }

   556     QVariantHash metadata;

   557     metadata.insert("screenshot", *pixmap);

   558     int times = 0;

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

   560     bool ok = false;

   561     bool retok = false;

   562     QString name;

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

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

   565         Before();

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

   567             

   568             name.setNum(i);

   569             ok = QMetaObject::invokeMethod(mActivityClient, "addActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name), Q_ARG(QVariant, variant), Q_ARG(QVariantHash, metadata));

   570             if (!ok || !retok) {

   571                 break;

   572             }            

   573         }

   574         After();

   575         Result();

   576         trymeasure.append(iResult);

   577         

   578         QList<QVariantHash> activities;

   579         ok  = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));    

   580     

   581         if (ok) {

   582             QString name;

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

   584                 name = activities.at(i).value(":ActivityName").toString();

   585                 ok = QMetaObject::invokeMethod(mActivityClient, "removeActivity", Q_RETURN_ARG(bool, retok), Q_ARG(QString, name));

   586                 if (!ok || !retok) {

   587                     break;

   588                 }

   589             }

   590         }

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

   592 

   593     }        

   594     mItemMessage.clear();

   595     mResultMessage.clear();

   596     if (!ok || !retok) {

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

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

   599         *mStream<<"error\n";

   600     } else {

   601         int averageint = average(trymeasure);

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

   603         writeResults(trymeasure, averageint);

   604     }

   605     mStream->flush();

   606     mItemLabel->setPlainText(mItemMessage);

   607     mResultLabel->setPlainText(mResultMessage);    

   608     

   609 }

   610 

   611 void MeasureTest::getTimesActivityData()

   612 {

   613     int times = 0;

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

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

   616     QList<int> trymeasure;

   617     

   618     QList<QVariantHash> activities;

   619     bool ok  = QMetaObject::invokeMethod(mActivityClient, "activities", Q_RETURN_ARG(QList<QVariantHash>, activities));

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

   621     if (ok) {

   622         QString name;

   623         QVariant data;        

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

   625             Before();

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

   627                 name = activities.at(i).value(":ActivityName").toString();

   628                 ok = QMetaObject::invokeMethod(mActivityClient, "activityData", Q_RETURN_ARG(QVariant, data), Q_ARG(QString, name));

   629                 if (!ok) {

   630                     break;

   631                 }

   632             }

   633             After();

   634             Result();

   635             trymeasure.append(iResult);

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

   637         }

   638     }

   639     mItemMessage.clear();

   640     mResultMessage.clear();

   641 

   642     if (!ok) {

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

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

   645         *mStream<<"error\n";

   646     } else {

   647         int averageint = average(trymeasure);

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

   649         writeResults(trymeasure, averageint);

   650     }

   651     mStream->flush();

   652     mItemLabel->setPlainText(mItemMessage);

   653     mResultLabel->setPlainText(mResultMessage);

   654 

   655 }

   656 

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

   658 {

   659     int count = list.count();

   660     int sum=0;

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

   662         sum += list.at(i);

   663     }

   664     sum = (sum+0.5)/count;

   665     return sum;

   666 }

   667 

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

   669 {

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

   671         *mStream<<"|  ";

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

   673         *mStream<<"  |\n";

   674     }

   675     *mStream<<"|  ";

   676     *mStream<<average;

   677     *mStream<<"  |\n";

   678 }