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

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
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;
            }
        }
    } 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);
}