/*
* 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);
        
        //invalid height
        QVERIFY(KErrNone == client->getThumbnail(TSize(50, 0), results[iter]->ImageSrc(), this));
        timeout.start();
        mLoop.exec();
        QVERIFY(timeout.isActive());
        timeout.stop();
        QVERIFY(mScreenshotHandle < 0);
        QVERIFY(this == mUserData);
        
        //invalid thumbnail
        QVERIFY(KErrNone == client->getThumbnail(TSize(50, 10), _L("s:/ome/fake/path.mbm"), this));
        timeout.start();
        mLoop.exec();
        QVERIFY(timeout.isActive());
        timeout.stop();
        QVERIFY(mScreenshotHandle < 0);
        QVERIFY(this == mUserData);
    }
    results.ResetAndDestroy();
}

QTEST_MAIN(T_ActivityClient)