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 "activitydebuger.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 <e32std.h>

    34 #include <HbInstance>

    35 

    36 #include <qservicemanager.h>

    37 #include "activitydebugerconsole.h"

    38 

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

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

    41 const char ActivityScreenshotKeyword [] = "screenshot";

    42 

    43 QTM_USE_NAMESPACE

    44 

    45 ActivityDebuger::ActivityDebuger(QGraphicsItem *parent) : HbView(parent), mActivityClient(NULL), mByteArray(NULL)

    46 {

    47     mThumbwait = 0;

    48     mThumbnull = 0;

    49     mThumbcurrent = 0;

    50     QServiceManager serviceManager;

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

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

    53     if (!mActivityClient) {

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

    55     }

    56 

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

    58     if (!mActivityManager) {

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

    60     }

    61     mTimesLabel = new HbLabel("Times");

    62     mBytesLabel = new HbLabel("Bytes");

    63     mPixmapLabel = new HbLabel("Pixmap");    

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

    65 

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

    67     mPixmap2 = new QPixmap(":/images/bird.bmp");

    68     mEmptyPixmap = new QPixmap();

    69 

    70 

    71     mTimesCombo = new HbComboBox();

    72     mLengthCombo = new HbComboBox();

    73     mPixmapCombo = new HbComboBox();

    74     mWidthCombo = new HbComboBox();

    75     mHeightCombo = new HbComboBox();

    76 

    77     mTimesCombo->addItem("1");

    78     mTimesCombo->addItem("2");

    79     mTimesCombo->addItem("4");

    80     mTimesCombo->addItem("5");

    81     mTimesCombo->addItem("10");

    82     mTimesCombo->addItem("20");

    83     mTimesCombo->addItem("40");

    84     mTimesCombo->addItem("60");

    85 

    86     QVariant variant;

    87     variant = 10;

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

    89     variant = 100;

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

    91     variant = 1024;

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

    93     variant = 10240;

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

    95     variant = 102400;

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

    97     variant = 1024*1024;

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

    99     

   100     mWidthCombo->addItem("360");

   101     mWidthCombo->addItem("180");

   102     mWidthCombo->addItem("128");

   103     mWidthCombo->addItem("90");

   104     

   105     mHeightCombo->addItem("640");

   106     mHeightCombo->addItem("320");

   107     mHeightCombo->addItem("160");

   108     mHeightCombo->addItem("128");

   109     

   110 

   111     mPixmapCombo->addItem("no");

   112     mPixmapCombo->addItem("yes");

   113     mPixmapCombo->addItem("grab");

   114 

   115     mSaveButton = new HbPushButton("Add");

   116     mGetButton = new HbPushButton("Activities");

   117     mDelButton = new HbPushButton("Delete");

   118     mGetDataButton = new HbPushButton("Get data");

   119     mUpdateButton = new HbPushButton("Update");

   120     mThumbButton = new HbPushButton("Get pixmaps");

   121     mClearButton = new HbPushButton("Clear");

   122     mDelMyButton = new HbPushButton("Reserved");

   123 

   124     mConsole = new ActivityDebugerConsole;

   125     

   126     mLayout  = new QGraphicsGridLayout();

   127     mLayout->addItem(mConsole, 0, 0, 3, 6);

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

   129     mLayout->addItem(mWidthCombo, 3, 2, 1, 2);

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

   131     mLayout->addItem(mTimesLabel, 4, 0, 1, 2);

   132     mLayout->addItem(mBytesLabel, 4, 2, 1, 2);

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

   134     mLayout->addItem(mTimesCombo, 5, 0, 1, 2);

   135     mLayout->addItem(mLengthCombo, 5, 2, 1, 2);

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

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

   138     mLayout->addItem(mGetDataButton, 6, 3, 1, 3);

   139     mLayout->addItem(mSaveButton, 7, 0, 1, 3);

   140     mLayout->addItem(mUpdateButton, 7, 3, 1, 3);

   141     mLayout->addItem(mGetButton, 8, 0, 1, 2);

   142     mLayout->addItem(mThumbButton, 8, 2, 1, 4);

   143     mLayout->addItem(mDelButton, 9, 0, 1, 3);

   144     mLayout->addItem(mDelMyButton, 9, 3, 1, 3);

   145     

   146     

   147     

   148     setLayout(mLayout);

   149 

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

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

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

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

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

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

   156     connect(mClearButton, SIGNAL(released()), mConsole, SLOT(clear()));

   157 

   158 

   159 

   160 }

   161 

   162 ActivityDebuger::~ActivityDebuger()

   163 {

   164     delete mEmptyPixmap;

   165     delete mPixmap;

   166     delete mPixmap2;

   167     delete mActivityClient;

   168     delete mActivityManager;

   169 }

   170 

   171 

   172 void ActivityDebuger::Before()

   173 {

   174     TTime time;

   175     time.HomeTime();

   176     iBefore = time.Int64();

   177 }

   178 

   179 void ActivityDebuger::After()

   180 {

   181     TTime time;

   182     time.HomeTime();

   183     iAfter = time.Int64();

   184 }

   185 

   186 void ActivityDebuger::Result()

   187 {

   188     TInt64 res(0);

   189     res = iAfter-iBefore;

   190     res = res/1000;

   191     iResult = res;

   192 }

   193 

   194 void  ActivityDebuger::deleteActivity()

   195 {

   196     mItemMeaage.clear();

   197     mItemMeaage += "***Remove all:\n";

   198     QList<QVariantHash> activities;

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

   200     bool retok = false;

   201     int items = 0;

   202     if (ok) {

   203         QString actname;

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

   205             actname = activities.at(i).value(ActivityActivityKeyword).toString();

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

   207             ok = ok*retok;

   208 

   209         mItemMeaage += "*";        

   210         mItemMeaage += actname;

   211         mItemMeaage += "; ";

   212         QString res;

   213         res.setNum(ok);

   214         mItemMeaage += res;

   215         

   216         mItemMeaage += "*\n";

   217         

   218         items++;

   219         }

   220     mItemMeaage += tr("*Items %1*\n").arg(items);    

   221     }

   222     else

   223         {

   224         mItemMeaage += "*Failed*\n";

   225         }

   226     

   227     UpdateConsole();

   228 

   229 }

   230 

   231 void  ActivityDebuger::getActivity()

   232 {

   233     mItemMeaage.clear();

   234     mItemMeaage += "***Activities list:\n";

   235     bool ok = false;

   236     QList<QVariantHash> activities;

   237     ok = QMetaObject::invokeMethod(mActivityManager, "activitiesList", Q_RETURN_ARG(QList<QVariantHash>, activities));

   238     if ( ok )

   239         {

   240         int items = 0;

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

   242             {

   243             QString actname = activities.at(i).value(ActivityActivityKeyword).toString();

   244             int appid = activities.at(i).value(ActivityApplicationKeyword).toInt(&ok);

   245             mItemMeaage += "*";

   246             QString aid;

   247             aid.setNum(appid);

   248             mItemMeaage += aid;

   249             mItemMeaage += "; ";

   250             mItemMeaage += actname;

   251             mItemMeaage += "; ";

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

   253             mItemMeaage += pixfile;

   254             QVariantHash::const_iterator node(activities.at(i).find("visible"));

   255             QString visible;

   256             if ( activities.at(i).end() != node )

   257                 {

   258                 bool vis = node.value().toBool();                

   259                 visible.setNum(vis);

   260                 }

   261             else

   262                 {

   263                 visible = "none";

   264                 }

   265             mItemMeaage += "; ";

   266             mItemMeaage += visible;

   267             QString res;

   268             res.setNum(ok);

   269             mItemMeaage += "; ";

   270             mItemMeaage += res;

   271             mItemMeaage += "*\n";

   272             

   273             items++;

   274             }

   275         mItemMeaage += tr("*Items %1*\n").arg(items);

   276         }

   277     else

   278         {

   279         mItemMeaage += "*Failed*\n";

   280         }

   281     UpdateConsole();

   282 }

   283 

   284 void  ActivityDebuger::getActivityThumb()

   285 {

   286     mItemMeaage.clear();

   287     mItemMeaage += "***Activities pixmaps:\n";

   288     UpdateConsole();

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

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

   291     mThumbwait = 0;

   292     mThumbnull = 0;

   293     mThumbcurrent = 0;

   294     bool ok = false;

   295     QList<QVariantHash> activities;

   296 

   297     ok = QMetaObject::invokeMethod(mActivityManager, "activitiesList", Q_RETURN_ARG(QList<QVariantHash>, activities));

   298     if ( ok )

   299         {

   300         mThumbwait = activities.count();

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

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

   303         QSize pixSize(width, height);

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

   305             {

   306             QString actname = activities.at(i).value(ActivityActivityKeyword).toString();

   307             int appid = activities.at(i).value(ActivityApplicationKeyword).toInt(&ok);

   308             QString pixfile;

   309             if ( ok )

   310                 {

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

   312                 void* userdata = reinterpret_cast<void*>(i);                

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

   314                 }

   315             

   316             mItemMeaage = "*";

   317             QString aid;

   318             aid.setNum(appid);

   319             mItemMeaage += aid;

   320             mItemMeaage += "; ";

   321             mItemMeaage += actname;

   322             mItemMeaage += "; ";

   323             QString locid = tr("locid=%1").arg(i);

   324             mItemMeaage += locid;

   325             mItemMeaage += "; ";

   326             QString res;

   327             res.setNum(ok);

   328             mItemMeaage += res;

   329             mItemMeaage += "*\n";

   330             UpdateConsole();

   331             }        

   332         }

   333     else

   334         {

   335         mItemMeaage += "*Failed*\n";

   336         UpdateConsole();

   337         }

   338 

   339 }

   340 

   341     

   342 

   343 void ActivityDebuger::saveActivity()

   344 {

   345     mItemMeaage.clear();

   346     mItemMeaage += "***Add:\n";

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

   348     delete mByteArray;

   349     mByteArray = NULL;

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

   351     QVariant variant;

   352     variant = *mByteArray;

   353     QPixmap *pixmap = NULL;

   354     QPixmap screenshot;

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

   356         pixmap = mPixmap;

   357     }

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

   359     {

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

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

   362         pixmap = &screenshot;

   363     }

   364     else

   365     {

   366         pixmap = mEmptyPixmap;

   367     }

   368         

   369     QVariantHash metadata;

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

   371     int times = 0;

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

   373     bool ok = false;

   374     bool retok = false;

   375     int items = 0;

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

   377         QString name;

   378         name.setNum(i);

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

   380         mItemMeaage += "*";            

   381         mItemMeaage += name;

   382         mItemMeaage += "; ";

   383         QString res;

   384         res.setNum(ok*retok);

   385         mItemMeaage += res;

   386         mItemMeaage += "*\n";

   387         

   388         items++;

   389     }

   390     mItemMeaage += tr("*Items %1*\n").arg(items);

   391     UpdateConsole();    

   392 }

   393 

   394 void ActivityDebuger::updateActivity()

   395 {

   396     mItemMeaage.clear();

   397     mItemMeaage += "***Update:\n";

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

   399     delete mByteArray;

   400     mByteArray = NULL;

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

   402     QVariant variant;

   403     variant = *mByteArray;

   404     QPixmap *pixmap = NULL;

   405     QPixmap screenshot;

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

   407         pixmap = mPixmap2;

   408     }

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

   410     {

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

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

   413         pixmap = &screenshot;

   414     }

   415     else

   416     {

   417         pixmap = mEmptyPixmap;

   418     }

   419     QVariantHash metadata;

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

   421     int times = 0;

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

   423     bool ok = false;

   424     bool retok = false;

   425     int items = 0;

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

   427         QString name;

   428         name.setNum(i);

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

   430 

   431         mItemMeaage += "*";            

   432         mItemMeaage += name;

   433         mItemMeaage += "; ";

   434         QString res;

   435         res.setNum(ok*retok);

   436         mItemMeaage += res;

   437         mItemMeaage += "*\n";

   438         

   439         items++;

   440     }

   441     mItemMeaage += tr("*Items %1*\n").arg(items);

   442     UpdateConsole();    

   443 }

   444 

   445 void ActivityDebuger::getActivityData()

   446 {

   447     mItemMeaage.clear();

   448     mItemMeaage += "***Activities data:\n";

   449     QList<QVariantHash> activities;

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

   451     if (ok) {

   452         QString name;

   453         QVariant data;

   454         int items = 0;

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

   456             name = activities.at(i).value(ActivityActivityKeyword).toString();

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

   458             const char* type = data.typeName();

   459             QString dtype(type);

   460             items++;

   461             

   462             mItemMeaage += "*";            

   463             mItemMeaage += name;

   464             mItemMeaage += "; ";

   465             mItemMeaage += dtype;

   466             mItemMeaage += "; ";

   467             QString res;

   468             res.setNum(ok);

   469             mItemMeaage += res;

   470             mItemMeaage += "*\n";    

   471         }

   472     mItemMeaage += tr("*Items %1*\n").arg(items);

   473     }

   474     else

   475         {

   476         mItemMeaage += "*Failed*\n";

   477         }

   478     UpdateConsole();

   479 }

   480 

   481 void ActivityDebuger::thumbnailReady(QPixmap pix, void * ptr)

   482     {

   483     mItemMeaage.clear();    

   484     QString pixsize;

   485     if ( pix.isNull() )

   486         {

   487         mThumbnull++;

   488         pixsize = "null";

   489         }    

   490     else

   491         {

   492         QSize size = pix.size();

   493         int w = size.width();

   494         int h = size.height();

   495         pixsize = tr("%1x%2").arg(w).arg(h);

   496         }

   497     int loc_id  = reinterpret_cast<int>(ptr);

   498     QString locid;

   499     locid = tr("locid=%1").arg(loc_id);

   500     mThumbcurrent++;

   501     

   502     mItemMeaage += "*";

   503     mItemMeaage += locid;

   504     mItemMeaage += "; ";

   505     mItemMeaage += pixsize;

   506     mItemMeaage += "*\n";

   507     

   508     if (mThumbcurrent == mThumbwait)

   509         {

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

   511         QString screennum = tr("*screennum: %1*\n").arg(mThumbwait);

   512         mItemMeaage += screennum;

   513         }

   514     UpdateConsole();

   515     }

   516 

   517 void ActivityDebuger::UpdateConsole()

   518     {

   519     mConsole->appendText(mItemMeaage);

   520     mConsole->scrollToBotton();

   521     }