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 #include <afactivitystorage.h>

    40 #include <afactivation.h>

    41 #include "afstorageglobals.h"

    42 

    43 

    44 QTM_USE_NAMESPACE

    45 

    46 ActivityDebuger::ActivityDebuger(QGraphicsItem *parent) : HbView(parent), mByteArray(NULL)

    47 {

    48     mThumbwait = 0;

    49     mThumbnull = 0;

    50     mThumbcurrent = 0;

    51     QServiceManager serviceManager;

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

    53 

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

    55     if (!mActivityManager) {

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

    57     }

    58     

    59     mActivityStorage = new AfActivityStorage;

    60     mActivation = new AfActivation;

    61     qRegisterMetaType<Af::ActivationReason>("Af::ActivationReason");

    62     connect(mActivation, SIGNAL(activated(Af::ActivationReason, QString, QVariantHash)), this, SLOT(loadActivityData(Af::ActivationReason, QString, QVariantHash)));

    63     

    64     

    65     mTimesLabel = new HbLabel("Times");

    66     mBytesLabel = new HbLabel("Bytes");

    67     mPixmapLabel = new HbLabel("Pixmap");    

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

    69 

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

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

    72     mEmptyPixmap = new QPixmap();

    73 

    74 

    75     mTimesCombo = new HbComboBox();

    76     mLengthCombo = new HbComboBox();

    77     mPixmapCombo = new HbComboBox();

    78     mWidthCombo = new HbComboBox();

    79     mHeightCombo = new HbComboBox();

    80 

    81     mTimesCombo->addItem("1");

    82     mTimesCombo->addItem("2");

    83     mTimesCombo->addItem("4");

    84     mTimesCombo->addItem("5");

    85     mTimesCombo->addItem("10");

    86     mTimesCombo->addItem("20");

    87     mTimesCombo->addItem("40");

    88     mTimesCombo->addItem("60");

    89 

    90     QVariant variant;

    91     variant = 10;

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

    93     variant = 100;

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

    95     variant = 1024;

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

    97     variant = 10240;

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

    99     variant = 102400;

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

   101     variant = 1024*1024;

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

   103     

   104     mWidthCombo->addItem("360");

   105     mWidthCombo->addItem("180");

   106     mWidthCombo->addItem("128");

   107     mWidthCombo->addItem("90");

   108     

   109     mHeightCombo->addItem("640");

   110     mHeightCombo->addItem("320");

   111     mHeightCombo->addItem("160");

   112     mHeightCombo->addItem("128");

   113     

   114 

   115     mPixmapCombo->addItem("no");

   116     mPixmapCombo->addItem("yes");

   117     mPixmapCombo->addItem("grab");

   118 

   119     mSaveButton = new HbPushButton("Save");

   120     mGetButton = new HbPushButton("Activities");

   121     mDelButton = new HbPushButton("Delete");

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

   123     mGetMyButton = new HbPushButton("Get my");

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

   125     mClearButton = new HbPushButton("Clear");

   126     mDelMyButton = new HbPushButton("Reserved");

   127 

   128     mConsole = new ActivityDebugerConsole;

   129     

   130     mLayout  = new QGraphicsGridLayout();

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

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

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

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

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

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

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

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

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

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

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

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

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

   144     mLayout->addItem(mGetMyButton, 7, 3, 1, 3);

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

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

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

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

   149     

   150     

   151     

   152     setLayout(mLayout);

   153 

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

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

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

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

   158     connect(mGetMyButton, SIGNAL(released()), this, SLOT(getMyActivity()));

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

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

   161 

   162 

   163 

   164 }

   165 

   166 ActivityDebuger::~ActivityDebuger()

   167 {

   168     delete mEmptyPixmap;

   169     delete mPixmap;

   170     delete mPixmap2;

   171     delete mActivityManager;

   172     delete mActivityStorage;

   173     delete mActivation;

   174 }

   175 

   176 

   177 void ActivityDebuger::Before()

   178 {

   179     TTime time;

   180     time.HomeTime();

   181     iBefore = time.Int64();

   182 }

   183 

   184 void ActivityDebuger::After()

   185 {

   186     TTime time;

   187     time.HomeTime();

   188     iAfter = time.Int64();

   189 }

   190 

   191 void ActivityDebuger::Result()

   192 {

   193     TInt64 res(0);

   194     res = iAfter-iBefore;

   195     res = res/1000;

   196     iResult = res;

   197 }

   198 

   199 void  ActivityDebuger::deleteActivity()

   200 {

   201     mItemMeaage.clear();

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

   203     QStringList activities = mActivityStorage->allActivities();    

   204     

   205     int items = 0;

   206     bool ok = false;

   207     QString actname;

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

   209         actname = activities.at(i);

   210         ok = mActivityStorage->removeActivity(actname);   

   211 

   212     mItemMeaage += "*";        

   213     mItemMeaage += actname;

   214     mItemMeaage += "; ";

   215     QString res;

   216     res.setNum(ok);

   217     mItemMeaage += res;

   218     

   219     mItemMeaage += "*\n";

   220     

   221     items++;

   222     }

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

   224 

   225     UpdateConsole();

   226 

   227 }

   228 

   229 void  ActivityDebuger::getActivity()

   230 {

   231     mItemMeaage.clear();

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

   233     bool ok = false;

   234     QList<QVariantHash> activities;

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

   236     if ( ok )

   237         {

   238         int items = 0;

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

   240             {

   241             getMetadata(activities.at(i));            

   242             

   243             items++;

   244             }

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

   246         }

   247     else

   248         {

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

   250         }

   251     UpdateConsole();

   252 }

   253 

   254 void ActivityDebuger::getMetadata(QVariantHash varianthash)

   255 {

   256     QString actname = varianthash.value(ActivityActivityKeyword).toString();

   257     int appid = varianthash.value(ActivityApplicationKeyword).toInt();

   258     mItemMeaage += "*";

   259     QString aid;

   260     aid.setNum(appid);

   261     mItemMeaage += aid;

   262     mItemMeaage += "; ";

   263     mItemMeaage += actname;

   264     mItemMeaage += "; ";

   265     QString pixfile = varianthash.value(ActivityScreenshotKeyword).toString();

   266     mItemMeaage += pixfile;

   267     QVariantHash::const_iterator node(varianthash.find(ActivityVisibility));

   268     QString visible;

   269     if ( varianthash.end() != node )

   270         {

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

   272         visible.setNum(vis);

   273         }

   274     else

   275         {

   276         visible = "none";

   277         }

   278     

   279     QVariantHash::const_iterator node2(varianthash.find(ActivityPersistence));

   280     QString persistence;

   281     if ( varianthash.end() != node2 )

   282         {

   283         bool per = node2.value().toBool();                

   284         persistence.setNum(per);

   285         }

   286     else

   287         {

   288         persistence = "none";

   289         }

   290 

   291 

   292     QVariantHash::const_iterator node3(varianthash.find(ActivityApplicationName));

   293     QString display;

   294     if ( varianthash.end() != node3 )

   295         {

   296         display = node3.value().toString();                

   297         }

   298     else

   299         {

   300         persistence = "none";

   301         }

   302         

   303     mItemMeaage += "; ";

   304     mItemMeaage += visible;

   305     mItemMeaage += "; ";

   306     mItemMeaage += persistence;

   307     mItemMeaage += "; ";

   308     mItemMeaage += display;

   309 }

   310 

   311 void  ActivityDebuger::getActivityThumb()

   312 {

   313     mItemMeaage.clear();

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

   315     UpdateConsole();

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

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

   318     mThumbwait = 0;

   319     mThumbnull = 0;

   320     mThumbcurrent = 0;

   321     bool ok = false;

   322     QList<QVariantHash> activities;

   323 

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

   325     if ( ok )

   326         {

   327         mThumbwait = activities.count();

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

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

   330         QSize pixSize(width, height);

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

   332             {

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

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

   335             QString pixfile;

   336             if ( ok )

   337                 {

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

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

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

   341                 }

   342             

   343             mItemMeaage = "*";

   344             QString aid;

   345             aid.setNum(appid);

   346             mItemMeaage += aid;

   347             mItemMeaage += "; ";

   348             mItemMeaage += actname;

   349             mItemMeaage += "; ";

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

   351             mItemMeaage += locid;

   352             mItemMeaage += "; ";

   353             QString res;

   354             res.setNum(ok);

   355             mItemMeaage += res;

   356             mItemMeaage += "*\n";

   357             UpdateConsole();

   358             }        

   359         }

   360     else

   361         {

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

   363         UpdateConsole();

   364         }

   365 

   366 }    

   367 

   368 void ActivityDebuger::saveActivity()

   369 {

   370     mItemMeaage.clear();

   371     mItemMeaage += "***Save:\n";

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

   373     delete mByteArray;

   374     mByteArray = NULL;

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

   376     QVariant variant;

   377     variant = *mByteArray;

   378     QPixmap *pixmap = NULL;

   379     QPixmap screenshot;

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

   381         pixmap = mPixmap;

   382     }

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

   384     {

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

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

   387         pixmap = &screenshot;

   388     }

   389     else

   390     {

   391         pixmap = mEmptyPixmap;

   392     }

   393         

   394     QVariantHash metadata;

   395     metadata.insert(ActivityScreenshotKeyword, *pixmap);

   396     int times = 0;

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

   398     bool ok = false;

   399     int items = 0;

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

   401         QString name;

   402         name.setNum(i);   

   403         metadata.insert(ActivityApplicationName, name);        

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

   405         mItemMeaage += "*";            

   406         mItemMeaage += name;

   407         mItemMeaage += "; ";

   408         QString res;

   409         res.setNum(ok);

   410         mItemMeaage += res;

   411         mItemMeaage += "*\n";

   412         

   413         items++;

   414     }

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

   416     UpdateConsole();    

   417 }

   418 

   419 void ActivityDebuger::getMyActivity()

   420 {

   421     mItemMeaage.clear();

   422     mItemMeaage += "***Get my activities:\n";

   423     QStringList activities = mActivityStorage->allActivities();  

   424     QString name;

   425     QVariantHash data;

   426     int items = 0;

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

   428         name = activities.at(i);

   429         data = mActivityStorage->activityMetaData(activities.at(i));        

   430         getMetadata(data);            

   431         items++;       

   432     }

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

   434     UpdateConsole();   

   435 }

   436 

   437 void ActivityDebuger::getActivityData()

   438 {

   439     mItemMeaage.clear();

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

   441     QStringList activities = mActivityStorage->allActivities();   

   442 

   443     QString name;

   444     QVariant data;

   445     int items = 0;

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

   447         name = activities.at(i);

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

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

   450         QString dtype(type);

   451         items++;

   452         

   453         mItemMeaage += "*";            

   454         mItemMeaage += name;

   455         mItemMeaage += "; ";

   456         mItemMeaage += dtype;

   457         mItemMeaage += "; ";        

   458         mItemMeaage += "*\n";    

   459     }

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

   461 

   462     UpdateConsole();

   463 }

   464 

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

   466     {

   467     mItemMeaage.clear();    

   468     QString pixsize;

   469     if ( pix.isNull() )

   470         {

   471         mThumbnull++;

   472         pixsize = "null";

   473         }    

   474     else

   475         {

   476         QSize size = pix.size();

   477         int w = size.width();

   478         int h = size.height();

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

   480         }

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

   482     QString locid;

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

   484     mThumbcurrent++;

   485     

   486     mItemMeaage += "*";

   487     mItemMeaage += locid;

   488     mItemMeaage += "; ";

   489     mItemMeaage += pixsize;

   490     mItemMeaage += "*\n";

   491     

   492     if (mThumbcurrent == mThumbwait)

   493         {

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

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

   496         mItemMeaage += screennum;

   497         }

   498     UpdateConsole();

   499     }

   500 

   501 void ActivityDebuger::UpdateConsole()

   502     {

   503     mConsole->appendText(mItemMeaage);

   504     mConsole->scrollToBotton();

   505     }

   506 

   507 void ActivityDebuger::loadActivityData(Af::ActivationReason reason, const QString &name, QVariantHash parameter)

   508 {

   509     mItemMeaage.clear();

   510     mItemMeaage += "***Activity requested:\n";

   511     int reasonint = static_cast<int>(reason);

   512     QString reasonstring;

   513     reasonstring.setNum(reasonint);

   514     int parametercount = parameter.count();

   515     QString parametercountstring;;

   516     parametercountstring.setNum(parametercount);

   517     

   518     

   519     mItemMeaage += "*";            

   520     mItemMeaage += name;

   521     mItemMeaage += "; ";

   522     mItemMeaage += reasonstring;

   523     mItemMeaage += "; ";        

   524     mItemMeaage += parametercountstring;

   525     mItemMeaage += "*\n"; 

   526     

   527     UpdateConsole();

   528 }