#include <fbs.h>

#include <s32mem.h>

#include <qvariant.h>

#include <XQConversions>

#include "afentry.h"

/**

 * Constructor

 */

/**

 * Destructor

 */

/**

 * Function establish connection to activity server

 * @return 0 on succees, error code otherwise

 */

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::addActivity(const QVariantHash &)

 */

int HsActivityDbClientPrivate::addActivity(const QVariantHash &privateData,

                                           const QVariantHash &publicData)

    return execute(AddActivity, privateData, publicData);

}

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

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::updateActivity(const QVariantHash &)

 */

int HsActivityDbClientPrivate::updateActivity(const QVariantHash &privateData,

                                              const QVariantHash &publicData)

{

    return execute(UpdateActivity, privateData, publicData);

}

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

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::removeActivity(const QVariantHash &)

 */

int HsActivityDbClientPrivate::removeActivity(const QVariantHash &activity)

{

    return execute(RemoveActivity, QVariantHash(), activity);

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::removeApplicationActivities(const QVariantHash &)

*/

int HsActivityDbClientPrivate::removeApplicationActivities(const QVariantHash &activity)

    return execute(RemoveApplicationActivities, QVariantHash(), activity);

}

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

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::activities(QList<QVariantHash> &);

 */

int HsActivityDbClientPrivate::activities(QList<QVariantHash>& result)

{

    return execute(Activities, result, QVariantHash());

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::applicationActivities(QList<QVariantHash> &, const QVariantHash &)

 */

int HsActivityDbClientPrivate::applicationActivities(QList<QVariantHash>& result,

        const QVariantHash &condition)

    return execute(ApplicationActivities, result, condition);

}

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

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::activityData(QVariant &, const QVariantHash &)

 */

int HsActivityDbClientPrivate::activityData(QVariant &result, const QVariantHash &activity)

{

    TRAPD(errNo,

    User::LeaveIfError(checkDataConstraint(ApplicationActivity, activity));

    activityDataL(result, activity);)

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::waitActivity(const QVariantHash &)

 */

    return execute(WaitActivity, QVariantHash(), activity);

    return execute(NotifyChange, QVariantHash(), QVariantHash());

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::launchActivity(const QVariantHash &)

 */

    return execute(LaunchActivity, QVariantHash(), activity);

/**

 * Interface implementation.

 * @see int HsActivityDbClientInterface::cancelWaitActivity()

 */

/**

 * Function start activity server process.

 * Function can leave on failure.

 */

/**

 * Function establish connection to activity server.

 * Function can leave on failure

 */

/**

 * Function execute remote call request.

 * @param function - remote function identyfier

 * @param activity - remote function parameters

 */

void HsActivityDbClientPrivate::execSimpleRequestL(int function,

                                                   const QVariantHash &privateData,

                                                   const QVariantHash &publicData)

    TPckgBuf<TInt> bitmapHdl(0);

    int flags(0);

    if(publicData.end() != publicData.find(ActivityPersistence) &&

       publicData[ActivityPersistence].toBool()) {

        flags |= CAfEntry::Persistent;

    }

    if(publicData.end() != publicData.find(ActivityVisibility) &&

       !publicData[ActivityVisibility].toBool()) {

        flags |= CAfEntry::Invisible;

    }

    CFbsBitmap* bitmap(0);

    if (publicData.end() != publicData.find(ActivityScreenshotKeyword)) {

        bitmap = publicData[ActivityScreenshotKeyword].value<QPixmap>().toSymbianCFbsBitmap();

        if (bitmap) {

            CleanupStack::PushL(bitmap);

            bitmapHdl = bitmap->Handle();

        }

    }

    RBuf8 prvBuffer, pubBuffer, data;

    CleanupClosePushL(data);

    CleanupClosePushL(prvBuffer);

    CleanupClosePushL(pubBuffer);

    prvBuffer << privateData;

    if (publicData.end() != publicData.find(ActivityScreenshotKeyword)) {

        QVariantHash localData(publicData);

        localData.remove(ActivityScreenshotKeyword);

        pubBuffer << localData;

    } else {

        pubBuffer << publicData;

    }

    HBufC *actId = XQConversions::qStringToS60Desc(publicData[ActivityActivityKeyword].toString());

    CAfEntry *entry = CAfEntry::NewL(flags,

                                     publicData[ActivityApplicationKeyword].toInt(),

                                     *actId,

                                     KNullDesC,

                                     prvBuffer,

                                     pubBuffer);

    CleanupStack::PopAndDestroy(actId);

    CleanupStack::PopAndDestroy(&pubBuffer);

    CleanupStack::PopAndDestroy(&prvBuffer);

    CleanupStack::PushL(entry);

    data.CreateL(entry->Size());

    RDesWriteStream stream(data);

    CleanupClosePushL(stream);

    stream << (*entry);

    CleanupStack::PopAndDestroy(&stream);

    CleanupStack::PopAndDestroy(entry);

    User::LeaveIfError(SendReceive(function, TIpcArgs(&data, &bitmapHdl)));

    if (0 != bitmap) {

        CleanupStack::PopAndDestroy(bitmap);

    }

}

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

/**

 * Function retrieve all stored activity

 * Function can leave on failure

 * @param result - list of activity

 */

void HsActivityDbClientPrivate::activitiesL(QList<QVariantHash>& result)

{

    result.clear();

    RBuf8 buffer;

    CleanupClosePushL(buffer);

    TPckgBuf<int> emptyFilter(0), length(0), taskId(0);

    User::LeaveIfError(SendReceive(Activities,

                                   TIpcArgs(&emptyFilter, &length, &taskId)));

    CAfEntry::ReallocL(buffer, length());

    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&taskId, &buffer)));

    RPointerArray<CAfEntry> entries;

    CleanupClosePushL(entries);

    entries << buffer;

    buffer.Close();//release unneeded resources

    while(entries.Count()) {

        QVariantHash publicData;

        publicData << entries[0]->Data(CAfEntry::Public);

        publicData.insert(ActivityScreenshotKeyword,

                          QString::fromUtf16(entries[0]->ImageSrc().Ptr(),

                                             entries[0]->ImageSrc().Length()));

        result.append(publicData);

        entries.Remove(0);

    }

    CleanupStack::PopAndDestroy(&entries);

    CleanupStack::PopAndDestroy(&buffer);

}

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

/**

 * Function retrieve all stored activity

 * Function can leave on failure

 * @param result - list of activity

 * @param cond - request conditions

 */

void HsActivityDbClientPrivate::applicationActivitiesL(QList<QVariantHash>& result,

                                                     const QVariantHash & condition)

{

    result.clear();

    RBuf8 buffer;

    CleanupClosePushL(buffer);

    CAfEntry *entry = CAfEntry::NewLC(0,

                                      condition[ActivityApplicationKeyword].toInt(),

                                      KNullDesC,

                                      KNullDesC,

                                      KNullDesC8,

                                      KNullDesC8);//filtering using application id only

    CAfEntry::ReallocL(buffer, entry->Size());

    RDesWriteStream writer(buffer);

    CleanupClosePushL(writer);

    writer << (*entry);

    CleanupStack::PopAndDestroy(&writer);

    CleanupStack::PopAndDestroy(entry);

    TPckgBuf<int> length(0), taskId(0);

    User::LeaveIfError(SendReceive(ApplicationActivities,

                                   TIpcArgs(&buffer, &length, &taskId)));

    CAfEntry::ReallocL(buffer, length());

    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&taskId, &buffer)));

    RPointerArray<CAfEntry> entries;

    CleanupClosePushL(entries);

    entries << buffer;

    buffer.Close();//release unneeded resources

    while(entries.Count()) {

        QVariantHash publicData;

        publicData << entries[0]->Data(CAfEntry::Public);

        publicData.insert(ActivityScreenshotKeyword,

                          QString::fromUtf16(entries[0]->ImageSrc().Ptr(),

                                             entries[0]->ImageSrc().Length()));

        result.append(publicData);

        entries.Remove(0);

    }

    CleanupStack::PopAndDestroy(&entries);

    CleanupStack::PopAndDestroy(&buffer);

}

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

/**

 * Function retrieve private data of stored activity

 * Function can leave on failure

 * @param result - list of activity

 * @param activity - request conditions

 */

void HsActivityDbClientPrivate::activityDataL(QVariant &result, const QVariantHash &activity)

{

    result.clear();

    RBuf8 buffer;

    CleanupClosePushL(buffer);

    {   // prepare entry to send

        HBufC *activityId = XQConversions::qStringToS60Desc(activity[ActivityActivityKeyword].toString());

        CleanupStack::PushL(activityId);

        CAfEntry *entry = CAfEntry::NewLC(0,

                                          activity[ActivityApplicationKeyword].toInt(),

                                          *activityId,

                                          KNullDesC,

                                          KNullDesC8,

                                          KNullDesC8);//filtering using application id only

        CAfEntry::ReallocL(buffer, entry->Size());

        RDesWriteStream writer(buffer);

        CleanupClosePushL(writer);

        writer << (*entry);

        CleanupStack::PopAndDestroy(&writer);

        CleanupStack::PopAndDestroy(entry);

        CleanupStack::PopAndDestroy(activityId);

    }

    {   // get data

        TPckgBuf<int> length(0), taskId(0);

        User::LeaveIfError(SendReceive(ApplicationActivity, TIpcArgs(&buffer, &length, &taskId)));

        CAfEntry::ReallocL(buffer, length());

        User::LeaveIfError(SendReceive(GetData, TIpcArgs(&taskId, &buffer)));

    }

    {   // read data to Qt structure

        CAfEntry *entry = CAfEntry::NewLC();

        RDesReadStream reader(buffer);

        CleanupClosePushL(reader);

        entry->InternalizeL(reader);

        CleanupStack::PopAndDestroy(&reader);

        buffer.Close(); //release unneeded resources

        QVariantHash privateData;

        privateData << entry->Data(CAfEntry::Private);

        result = privateData.value(ActivityDataKeyword);

        CleanupStack::PopAndDestroy(entry);

    }

    CleanupStack::PopAndDestroy(&buffer);

void HsActivityDbClientPrivate::launchActivityL(const QVariantHash &activity)

    TPckgC<TInt> applicationId(activity[ActivityApplicationKeyword].toInt());

    HBufC8 *activityId = XQConversions::qStringToS60Desc8(activity[ActivityActivityKeyword].toString());

    CleanupStack::PushL(activityId);

    TPtrC8 empty(KNullDesC8);

    User::LeaveIfError(SendReceive(LaunchActivity,

                                   TIpcArgs(&applicationId, activityId, &empty, &empty)));

    CleanupStack::PopAndDestroy(activityId);