/*
* 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:
*
*/

#include "hsactivitydbclient_p.h"
#include "hsactivitydbasyncrequest_p.h"
#include "hsactivityglobals.h"
#include "hsserializer.h"
#include <qvariant.h>


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
HsActivityDbClientPrivate::HsActivityDbClientPrivate(HsActivityDbAsyncRequestObserver &observer)
{
    mAsyncDataHandler = HsActivityDbAsyncRequestPrivate::NewL(observer, *this);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
HsActivityDbClientPrivate::~HsActivityDbClientPrivate()
{
    delete mAsyncDataHandler;
    Close();
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::connect()
{
    TRAPD(errNo, connectL());
    return errNo;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::addActivity(const QVariantHash &activity)
{
    TRAPD(errNo, execSimpleRequestL(AddActivity, activity);)
    return errNo;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::updateActivity(const QVariantHash &activity)
{
    TRAPD(errNo, execSimpleRequestL(UpdateActivity, activity);)
    return errNo;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::removeActivity(const QVariantHash &activity)
{
    TRAPD(errNo, execSimpleRequestL(RemoveActivity, activity);)
    return errNo;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::removeApplicationActivities(const QVariantHash &activity)
{
    TRAPD(errNo, execSimpleRequestL(RemoveApplicationActivities, activity);)
    return errNo;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::activities(QList<QVariantHash>& result)
{
    TRAPD(errNo, activitiesL(result));
    return errNo;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::applicationActivities(QList<QVariantHash>& result,
        const QVariantHash &condition)
{
    TRAPD(errNo, applicationActivitiesL(result, condition));
    return errNo;
}


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::waitActivity(const QVariantHash &activity)
{
    TRAPD(errNo, waitActivityL(activity);)
    return errNo;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::launchActivity(const QVariantHash &activity)
{
    TRAPD(errNo, execSimpleRequestL(LaunchActivity, activity);)
    return errNo;
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::cancelWaitActivity()
{
    return SendReceive(CancelWait, TIpcArgs());
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::startServerL()
{
    RProcess server;
    const TUidType uid(KNullUid, KNullUid, KActivityServerUid);
    User::LeaveIfError(server.Create(KActivityServerName, KNullDesC, uid));
    TRequestStatus stat;
    server.Rendezvous(stat);
    if (stat != KRequestPending) {
        server.Kill(0);
    } else {
        server.Resume();
    }
    User::WaitForRequest(stat);
    int errNo = (EExitPanic == server.ExitType()) ?
                KErrGeneral : stat.Int();
    if (KErrCancel == errNo) {
        errNo = KErrNone;
    }
    server.Close();
    User::LeaveIfError(errNo);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::connectL()
{
    const int asyncMessageSlots(4);
    const int maxRetry(4);

    TInt retry = maxRetry;
    TInt errNo(KErrNone);
    do {
        errNo = CreateSession(KActivityServerName, TVersion(0, 0, 0), asyncMessageSlots);
        if (KErrNotFound != errNo && KErrServerTerminated != errNo) {
            retry =0;
        } else {
            TRAP(errNo, startServerL());
            if (KErrNone != errNo && KErrAlreadyExists != errNo) {
                retry =0;
                errNo = CreateSession(KActivityServerName, TVersion(0, 0, 0), asyncMessageSlots);
            }
        }
    } while (--retry > 0);
    User::LeaveIfError(errNo);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::execSimpleRequestL(int function, const QVariantHash &activity)
{
    RBuf8 data;
    CleanupClosePushL(data);
    data.CreateL(256);
    data << activity;
    User::LeaveIfError(SendReceive(function, TIpcArgs(&data)));
    CleanupStack::PopAndDestroy(&data);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::requestedActivityNameL(QString &result,
                                                const QVariantHash &activity)
{
    RBuf8 data;
    TPckgBuf<int> sizeBuf;
    CleanupClosePushL(data);
    data.CreateL(256);
    data << activity;
    User::LeaveIfError(SendReceive(RequestedActivityName, TIpcArgs(&data,&sizeBuf)));
    if (sizeBuf() > data.MaxSize()) {
        data.ReAlloc(sizeBuf());
    }
    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&data)));
    result = QString::fromAscii(reinterpret_cast<const char *>(data.Ptr()),
                                data.Length());
    CleanupStack::PopAndDestroy(&data);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::activitiesL(QList<QVariantHash>& result)
{
    RBuf8 data;
    TPckgBuf<int> sizeBuf;
    CleanupClosePushL(data);
    data.CreateL(256);
    User::LeaveIfError(SendReceive(Activities, TIpcArgs(&data, &sizeBuf)));
    if (sizeBuf() > data.MaxSize()) {
        data.ReAlloc(sizeBuf());
    }
    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&data)));
    result << data;
    CleanupStack::PopAndDestroy(&data);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::applicationActivitiesL(QList<QVariantHash>& result,
                                                     const QVariantHash & condition)
{
    RBuf8 data;
    TPckgBuf<int> sizeBuf;
    CleanupClosePushL(data);
    data.CreateL(256);
    data << condition;
    User::LeaveIfError(SendReceive(ApplicationActivities, TIpcArgs(&data, &sizeBuf)));
    if (sizeBuf() > data.MaxSize()) {
        data.ReAlloc(sizeBuf());
    }
    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&data)));
    result << data;
    CleanupStack::PopAndDestroy(&data);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::waitActivityL(const QVariantHash &activity)
{
    if (mAsyncDataHandler->IsActive()) {
        User::Leave(KErrServerBusy);
    } else {
        mAsyncDataHandler->waitActivity(activity);
    }
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::getData(RBuf8 &data)
{
    SendReceive(GetData, TIpcArgs(&data));
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void HsActivityDbClientPrivate::sendDataAsync(int func,
                                              const TIpcArgs &data, 
                                              TRequestStatus& status)
{
    SendReceive(func, data, status);
}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
int HsActivityDbClientPrivate::getThumbnail(QPixmap &dst, const QString & src)
{
    RBuf8 data;
    QVariantHash thumbnailRequest;
    thumbnailRequest.insert(ActivityScreenshotKeyword, src);
    TPckgBuf<int> sizeBuf(0);
    CleanupClosePushL(data);
    data.CreateL(256);
    data << thumbnailRequest;
    User::LeaveIfError(SendReceive(GetThumbnail, TIpcArgs(&data, &sizeBuf)));
    if (sizeBuf() > data.MaxSize()) {
        data.ReAlloc(sizeBuf());
    }
    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&data)));
    dst << data;
    CleanupStack::PopAndDestroy(&data);
    return 0;
}