/*

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

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

//

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

//

{

    mAsyncDataHandler = HsActivityDbAsyncRequestPrivate::NewL(observer, *this);

}

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

//

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

//

HsActivityDbClientPrivate::~HsActivityDbClientPrivate()

{

    delete mAsyncDataHandler;

    Close();

}

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

//

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

//

int HsActivityDbClientPrivate::connect()

{

    TRAPD(errNo, connectL());

    return errNo;

}

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

//

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

//

int HsActivityDbClientPrivate::addActivity(const QVariantHash &activity)

{

}

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

//

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

//

int HsActivityDbClientPrivate::updateActivity(const QVariantHash &activity)

{

}

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

//

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

//

int HsActivityDbClientPrivate::removeActivity(const QVariantHash &activity)

{

}

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

//

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

//

int HsActivityDbClientPrivate::removeApplicationActivities(const QVariantHash &activity)

{

}

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

//

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

//

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

{

    TRAPD(errNo, activitiesL(result));

    return errNo;

}

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

//

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

//

{

    TRAPD(errNo, applicationActivitiesL(result, condition));

    return errNo;

}

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

//

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

//

int HsActivityDbClientPrivate::waitActivity(const QVariantHash &activity)

{

    return errNo;

}

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

//

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

//

int HsActivityDbClientPrivate::launchActivity(const QVariantHash &activity)

{

    return errNo;

}

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

//

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

//

int HsActivityDbClientPrivate::cancelWaitActivity()

{

    return SendReceive(CancelWait, TIpcArgs());

}

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

//

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

//

void HsActivityDbClientPrivate::startServerL()

{

    RProcess server;

    const TUidType uid(KNullUid, KNullUid, KActivityServerUid);

    TRequestStatus stat;

        server.Kill(0);

    } else {

        server.Resume();

    }

    User::WaitForRequest(stat);

                KErrGeneral : stat.Int();

        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 {

            retry =0;

        } else {

            TRAP(errNo, startServerL());

            if (KErrNone != errNo && KErrAlreadyExists != errNo) {

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

}

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

//

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

//

                                                const QVariantHash &activity)

{

    RBuf8 data;

    TPckgBuf<int> sizeBuf;

    CleanupClosePushL(data);

    data.CreateL(256);

    data << activity;

    User::LeaveIfError(SendReceive(RequestedActivityName, TIpcArgs(&data,&sizeBuf)));

    }

    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&data)));

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

    }

    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&data)));

    result << data;

    CleanupStack::PopAndDestroy(&data);

}

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

//

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

//

                                                     const QVariantHash & condition)

{

    RBuf8 data;

    TPckgBuf<int> sizeBuf;

    CleanupClosePushL(data);

    data.CreateL(256);

    data << condition;

    User::LeaveIfError(SendReceive(ApplicationActivities, TIpcArgs(&data, &sizeBuf)));

    }

    User::LeaveIfError(SendReceive(GetData, TIpcArgs(&data)));

    result << data;

    CleanupStack::PopAndDestroy(&data);

}

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

//

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

//

void HsActivityDbClientPrivate::waitActivityL(const QVariantHash &activity)

{

        User::Leave(KErrServerBusy);

    } else {

        mAsyncDataHandler->waitActivity(activity);

    }

}

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

//

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

//

{

    SendReceive(GetData, TIpcArgs(&data));

}

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

//

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

//

void HsActivityDbClientPrivate::sendDataAsync(int func,

                                              const TIpcArgs &data, 

                                              TRequestStatus& status)

{

    SendReceive(func, data, status);

}