/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Main test class for hsutils library.

*

*/

#include "t_activityclient.h"

#include <s32mem.h>

#include <fbs.h>

#include <QPainter>

#include <QScopedPointer>

#include <XQConversions>

#include <afstorageglobals.h>

#include <afentry.h>

#include "afasyncrequest_p.h"

#include "afthumbnailrequest_p.h"

#include "afstorageclient.h"

_LIT(KActivityName, "ActivityName");

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

T_ActivityClient::T_ActivityClient() : mBitmap(0), mData(0), mRunningTask(0), mScreenshot(0), mUserData(0)

{       

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

T_ActivityClient::~T_ActivityClient()

{

    delete mData;

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::initTestCase()

{

    QPixmap screenshot(20, 20);    

    {

        QPainter painter(&screenshot);

        painter.setBrush(Qt::black);

        painter.drawRect(screenshot.rect());

        painter.setBrush(QColor::fromHsv(255, 255, 255));

        painter.drawEllipse(screenshot.rect());

    }

    QScopedPointer<CFbsBitmap> bitmap(screenshot.toSymbianCFbsBitmap());

    mBitmap = new CFbsBitmap();

    QCOMPARE(mBitmap->Duplicate(bitmap->Handle()), KErrNone);    

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::cleanupTestCase()

{

    delete mBitmap;

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::waitActivityRequestCompleted(int result,

                                const TDesC8 &data)

{

    if (mData) {

        delete mData;

    }

    RBuf converter;

    converter.CreateMaxL(data.Length());

    converter.Copy(data);

    mData = converter.Alloc();

    converter.Close();

    mRealResponse = result;

    if(mLoop.isRunning()) {

        mLoop.exit();

    }

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::getThumbnailRequestCompleted(int result,

                            int bitmapHandle, 

                            void* userData)

{

    mScreenshotHandle = bitmapHandle;    

    mScreenshot = new CFbsBitmap();

    mScreenshot->Duplicate(mScreenshotHandle);    

    mUserData = userData;

    mRealResponse = result;

    if(mLoop.isRunning()) {

        mLoop.exit();

    }    

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::dataChangeNotificationCompleted(int result)

{

    mRealResponse = result;

    if(mLoop.isRunning()) {

        mLoop.exit();

    }

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::PushL(CBase* asyncTask)

{

    mRunningTask = asyncTask; 

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::Pop(CBase* asyncTask)

{

    Q_UNUSED(asyncTask);

    mRunningTask = 0;

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::executeL(int function)

{

    Q_UNUSED(function);

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::sendAsync(int function, const TIpcArgs &args, TRequestStatus& status)

{

    Q_UNUSED(function);

    Q_UNUSED(args);

    TRequestStatus *requestStatus(&status);

    User::RequestComplete(requestStatus, mExpectedResponse);

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::getDataL(int id, TDes8& buffer)

{

    Q_UNUSED(id);

    Q_UNUSED(buffer);

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testEntry()

{

    const TInt KActivityFlags(qHash("Some activity flags"));

    const TInt KApplicationId(qHash("Some application id"));

    _LIT(KActivityId, "Some activity id");

    _LIT(KActivityThumnail, "s:\\ome\\activity\\img.png");

    _LIT8(KPrivateData, "Some private data");

    _LIT8(KPublicData, "Some public data");

    struct TestDataSet{

    TInt mFlags;

    TInt mAppId;

    const TDesC& mActId;

    const TDesC& mImgPath;

    const TDesC8& mPriv;

    const TDesC8& mPub;

    } testData [] = {{KActivityFlags, KApplicationId, KActivityId(), KActivityThumnail(), KPrivateData(), KPublicData()},

                     {KActivityFlags, KApplicationId, KNullDesC, KActivityThumnail(), KPrivateData(), KPublicData()}, 

                     {KActivityFlags, KApplicationId, KActivityId(), KNullDesC, KPrivateData(), KPublicData()}, 

                     {KActivityFlags, KApplicationId, KActivityId(), KActivityThumnail(), KNullDesC8, KPublicData()},

                     {KActivityFlags, KApplicationId, KActivityId(), KActivityThumnail(), KPrivateData(), KNullDesC8()}};

    const int count(sizeof(testData) / sizeof(TestDataSet));

    CAfEntry * entry(0);

    RBuf8 serializedEntry;

    CleanupClosePushL(serializedEntry);

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

        entry = CAfEntry::NewL(testData[i].mFlags, 

                                testData[i].mAppId,

                                testData[i].mActId,

                                testData[i].mImgPath,

                                testData[i].mPriv,

                                testData[i].mPub);

        CleanupStack::PushL(entry);

        QVERIFY(entry->Flags() == testData[i].mFlags);

        QVERIFY(entry->ApplicationId() == testData[i].mAppId);

        QVERIFY(0 == entry->ActivityId().Compare(testData[i].mActId));

        QVERIFY(0 == entry->ImageSrc().Compare(testData[i].mImgPath));

        QVERIFY(0 == entry->Data(CAfEntry::Private).Compare(testData[i].mPriv));

        QVERIFY(0 == entry->Data(CAfEntry::Public).Compare(testData[i].mPub));

        if(serializedEntry.MaxLength() < entry->Size()) {

            serializedEntry.ReAllocL(entry->Size());

        }

        RDesWriteStream writer(serializedEntry);

        CleanupClosePushL(writer);

        writer << (*entry);

        CleanupStack::PopAndDestroy(&writer);

        CleanupStack::PopAndDestroy(entry);

        entry = CAfEntry::NewL();

        CleanupStack::PushL(entry);

        RDesReadStream reader(serializedEntry);

        CleanupClosePushL(reader);

        reader >> (*entry);

        CleanupStack::PopAndDestroy(&reader);

        QVERIFY(entry->Flags() == testData[i].mFlags);

        QVERIFY(entry->ApplicationId() == testData[i].mAppId);

        QVERIFY(0 == entry->ActivityId().Compare(testData[i].mActId));

        QVERIFY(0 == entry->ImageSrc().Compare(testData[i].mImgPath));

        QVERIFY(0 == entry->Data(CAfEntry::Private).Compare(testData[i].mPriv));

        QVERIFY(0 == entry->Data(CAfEntry::Public).Compare(testData[i].mPub));

        CleanupStack::PopAndDestroy(entry);        

    }

    CleanupStack::PopAndDestroy(&serializedEntry);

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testAsyncRequest()

{

    mExpectedResponse = KErrNone;

    CAfAsyncRequestPrivate::NewLD(*this, *this, WaitActivity);

    mLoop.exec();

    QVERIFY(mExpectedResponse == mRealResponse);

    QVERIFY(0 == mRunningTask);

    mExpectedResponse = KErrGeneral;

    CAfAsyncRequestPrivate::NewLD(*this, *this, WaitActivity);

    mLoop.exec();

    QVERIFY(mExpectedResponse == mRealResponse);

    QVERIFY(0 == mRunningTask);

    mExpectedResponse = KErrNone;

    CAfAsyncRequestPrivate::NewLD(*this, *this, NotifyChange);

    mLoop.exec();

    QVERIFY(mExpectedResponse == mRealResponse);

    QVERIFY(0 == mRunningTask);

    mExpectedResponse = KErrGeneral;

    CAfAsyncRequestPrivate::NewLD(*this, *this, NotifyChange);

    mLoop.exec();

    QVERIFY(mExpectedResponse == mRealResponse);

    QVERIFY(0 == mRunningTask);

    mExpectedResponse = KErrGeneral;

    CAfThumbnailRequestPrivate::NewLD(*this, *this, TSize(), _L("f://ake//path.mif"), 0);

    mLoop.exec();

    QVERIFY(mExpectedResponse == mRealResponse);

    QVERIFY(0 == mRunningTask);

    mExpectedResponse = KErrNone;

    CAfThumbnailRequestPrivate::NewLD(*this, *this, TSize(), _L("f://ake//path.mif"), 0);

    mLoop.exec();

    QVERIFY(mExpectedResponse == mRealResponse);

    QVERIFY(0 == mRunningTask);

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testCreateClient()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testAddActivity()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    client->removeActivity(*entry.data());

    QVERIFY(KErrNone == client->addActivity(*entry.data(), mBitmap->Handle()));

    QVERIFY(KErrNone != client->addActivity(*entry.data(), mBitmap->Handle()));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testUpdateActivity()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    client->removeActivity(*entry.data());

    client->addActivity(*entry.data(), mBitmap->Handle());

    QVERIFY(KErrNone == client->updateActivity(*entry.data(), mBitmap->Handle()));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testSaveActivity()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    client->removeActivity(*entry.data());

    QVERIFY(KErrNone == client->saveActivity(*entry.data(), mBitmap->Handle()));

    QVERIFY(KErrNone == client->saveActivity(*entry.data(), mBitmap->Handle()));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testRemoveActivity()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    client->removeActivity(*entry.data());

    client->addActivity(*entry.data(), mBitmap->Handle());

    QVERIFY(KErrNone == client->removeActivity(*entry.data()));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testRemoveApplicationActivities()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    client->removeActivity(*entry.data());

    client->addActivity(*entry.data(), mBitmap->Handle());

    QVERIFY(KErrNone == client->removeApplicationActivities(*entry.data()));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testActivities()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    client->removeActivity(*entry.data());

    int activityCountBeforeAdding, activityCountAfterAdding;

    {

        RPointerArray<CAfEntry> results;

        int callResult = client->activities(results);

        activityCountBeforeAdding = results.Count();

        results.ResetAndDestroy();

        QVERIFY(KErrNone == callResult);

    }

    QVERIFY(KErrNone == client->addActivity(*entry.data(), mBitmap->Handle()));

    {

        RPointerArray<CAfEntry> results;

        int callResult = client->activities(results);

        activityCountAfterAdding = results.Count();

        results.ResetAndDestroy();

        QVERIFY(KErrNone == callResult);

    }    

    QCOMPARE(activityCountAfterAdding, activityCountBeforeAdding + 1);

    client->removeActivity(*entry.data());

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testApplicationActivities()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    QVERIFY(KErrNone == client->removeApplicationActivities(*entry.data()));    

    const QString expectedActivityName("ActivityName%1");

    const int activityCount(20);

    {

        RPointerArray<CAfEntry> results;

        int callResult = client->applicationActivities(results, *entry.data());

        int resultCount = results.Count();

        results.ResetAndDestroy();

        QVERIFY(KErrNone == callResult);

        QCOMPARE(resultCount, 0);

    }

    for (int i=0; i < activityCount; ++i) {

        QScopedPointer<HBufC> activityName(XQConversions::qStringToS60Desc(QString(expectedActivityName).arg(i)));

        QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, *activityName.data(), KNullDesC(), KNullDesC8(), KNullDesC8()));

        client->addActivity(*entry.data(), mBitmap->Handle());

    }

    {

        RPointerArray<CAfEntry> results;

        int callResult = client->applicationActivities(results, *entry.data());

        int resultCount = results.Count();

        results.ResetAndDestroy();

        QVERIFY(KErrNone == callResult);

        QCOMPARE(resultCount, activityCount);

    }

    QVERIFY(KErrNone == client->removeApplicationActivities(*entry.data()));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testGetData()

{

    _LIT8(KPrivateData, "My private data");

    _LIT8(KPublicData, "My public data");

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KPrivateData(), KPublicData()));

    client->removeActivity(*entry.data());

    QVERIFY(KErrNone == client->addActivity(*entry.data(), mBitmap->Handle()));

    CAfEntry *result(0);

    QVERIFY(0 == client->activityData(result, *entry.data()));

    QScopedPointer<CAfEntry> guardedResult(result);

    QVERIFY(0 == guardedResult->Data(CAfEntry::Private).Compare(KPrivateData()));

    QVERIFY(0 == guardedResult->Data(CAfEntry::Public).Compare(KPublicData()));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testWaitLaunchActivity()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfStorageClient> launcher(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, RProcess().SecureId().iId, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    QVERIFY(KErrNone == client->waitActivity());

    QVERIFY(KErrNone == launcher->launchActivity(*entry.data()));

    mLoop.exec();

    QVERIFY(mData);

    QVERIFY(0 == mData->Compare(KActivityName()));

}

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void T_ActivityClient::testGetThumbnail()

{

    QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));

    QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, RProcess().SecureId().iId, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));

    client->removeActivity(*entry.data());

    QVERIFY(KErrNone == client->addActivity(*entry.data(), mBitmap->Handle()));

    RPointerArray<CAfEntry> results;    

    QVERIFY(KErrNone == client->activities(results));

    QTimer timeout;

    timeout.setSingleShot(true);

    timeout.setInterval(5000);

    mLoop.connect(&timeout, SIGNAL(timeout()), SLOT(quit()));

    for (int iter=0; iter < results.Count(); ++iter) {

        //valid thumbnail

        QVERIFY(KErrNone == client->getThumbnail(TSize(50, 10), results[iter]->ImageSrc(), this));

        timeout.start();

        mLoop.exec();

        QVERIFY(timeout.isActive());

        timeout.stop();        

        QVERIFY(mScreenshotHandle >= 0);

        {

            QScopedPointer<CFbsBitmap> bitmap(new CFbsBitmap());

            QCOMPARE(bitmap->Duplicate(mScreenshotHandle), KErrNone);    

            TSize bitmapSize = bitmap->SizeInPixels();

            QVERIFY(50 >= bitmapSize.iWidth);

            QVERIFY(10 >= bitmapSize.iHeight);

            delete mScreenshot;

            mScreenshot = 0;

        }

        QVERIFY(this == mUserData);

        //invalid width

        QVERIFY(KErrNone == client->getThumbnail(TSize(0, 10), results[iter]->ImageSrc(), this));

        timeout.start();

        mLoop.exec();

        QVERIFY(timeout.isActive());

        timeout.stop();

        QVERIFY(mScreenshotHandle < 0);

        QVERIFY(this == mUserData);