/*

 * Copyright (c) 2007 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 <QDebug>

#include "caclientnotifierproxy.h"

#include "caentry.h"

#include "cainnerentry.h"

#include "caobjectadapter.h"

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

//

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

CaClientNotifierProxy::CaClientNotifierProxy(QObject *parent) :

    QObject(parent)

{

}

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

//

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

CaClientNotifierProxy::~CaClientNotifierProxy()

{

}

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

//

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

void CaClientNotifierProxy::entryChanged(TInt entryId,

    TChangeType changeType) const

{

    qDebug() << "CaClientProxy::entryChanged entryId:"

        << entryId << "changeType:" << changeType;

    int entryChangedId(entryId);

    ChangeType entryChangeType(AddChangeType);

    CaObjectAdapter::convert(changeType, entryChangeType);

    emit signalEntryChanged(entryChangedId, entryChangeType);

}

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

//

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

void CaClientNotifierProxy::entryChanged(const CCaInnerEntry &entry,

    TChangeType changeType) const

{

    qDebug() << "CaClientProxy::entryChanged changeType:" << changeType;

    CaEntry *caEntry = new CaEntry(static_cast<EntryRole>(entry.GetRole()));

    ChangeType entryChangeType(AddChangeType);

    CaObjectAdapter::convert(entry, *caEntry);

    CaObjectAdapter::convert(changeType, entryChangeType);

    emit signalEntryChanged(*caEntry, entryChangeType);

}

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

//

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

void CaClientNotifierProxy::entryTouched(TInt id) const

{

    qDebug() << "CaClientProxy::entryTouched id:" << id;

    emit signalEntryTouched(id);

}

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

//

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

void CaClientNotifierProxy::groupContentChanged(TInt groupId) const

{

    qDebug() << "CaClientProxy::groupContentChanged groupId:" << groupId;

    int groupChangedId(groupId);

    emit signalGroupContentChanged(groupChangedId);

}

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

//

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

int CaClientNotifierProxy::registerNotifier(

    const CaNotifierFilter *notifierFilter,

    CaNotifierPrivate::NotifierType notifierType,

    const CaClientNotifierProxy *notifierProxy)

{

    qDebug() << "CaClientProxy::registerNotifier notifierType:"

        << notifierType;

    CCaInnerNotifierFilter::TNotifierType innerNotifierType(

        CCaInnerNotifierFilter::EEntryChangedWithId);

    CaObjectAdapter::convert(notifierType,

        innerNotifierType);

    CCaInnerNotifierFilter *innerNotifierFilter(NULL);

    TRAPD(error,

        innerNotifierFilter =

            CCaInnerNotifierFilter::NewLC(innerNotifierType);

        CaObjectAdapter::convertL(*notifierFilter, *innerNotifierFilter);

        CleanupStack::Pop(innerNotifierFilter)

    );

    if (!error) {

        // Lock the access to mSessions.

        // It will be automatically unlocked at the end of the current range.

        QMutexLocker locker(&mMutex);

        RCaClientNotifierSession *session = findSession();

        if (!session) {

            session = newSession(error);

        }

        if (!error) {

            error = session->RegisterNotifier(innerNotifierFilter,

                notifierFilter, notifierProxy);

        }

    }

    qDebug() << "CaClientProxy::registerNotifier result:" << error;

    return error;

}

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

//

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

void CaClientNotifierProxy::unregisterNotifier(

     const CaNotifierFilter &notifierFilter,

     CaNotifierPrivate::NotifierType notifierType)

{

    qDebug() << "CaClientProxy::unregisterNotifier notifierType:"

        << notifierType;

    CCaInnerNotifierFilter::TNotifierType innerNotifierType(

        CCaInnerNotifierFilter::EEntryChangedWithId);

    CaObjectAdapter::convert(

        notifierType,

        innerNotifierType);

    TInt pos = findSession(notifierFilter, innerNotifierType);

    if (pos != KErrNotFound) {

        // Lock the access to mSessions.

        // It will be automatically unlocked at the end of the current range.

        QMutexLocker locker(&mMutex);

        mSessions[pos].UnregisterNotifier(&notifierFilter,

            innerNotifierType);

        if (mSessions[pos].SubsessionsCount() == 0) {

            mSessions[pos].Close();

            mSessions.Remove(pos);

        }

    }

}

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

//

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

RCaClientNotifierSession *CaClientNotifierProxy::findSession()

{

    RCaClientNotifierSession *session(NULL);

    TInt count(mSessions.Count());

    for (int i = 0; i < count; i++) {

        if (mSessions[i].SubsessionsCount() < KDefaultMessageSlots) {

            session = &mSessions[i];

            break;

        }

    }

    return session;

}

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

//

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

TInt CaClientNotifierProxy::findSession(

    const CaNotifierFilter &notifierFilter,

    CCaInnerNotifierFilter::TNotifierType innerNotifierType) const

{

    TInt count(mSessions.Count());

    TInt pos(KErrNotFound);

    for (int i = 0; i < count; i++) {

        if (mSessions[i].ContainsSubsession(&notifierFilter,

            innerNotifierType)) {

            pos = i;

            break;

        }

    }

    return pos;

}

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

//

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

RCaClientNotifierSession *CaClientNotifierProxy::newSession(TInt &error)

{

    RCaClientNotifierSession session;

    error = session.Connect();

    if (!error) {

        error = mSessions.Append(session);

    }

    if (error) {

        session.Close();

        qDebug("CaClientProxy::newSession: error (%d)", error);

        return NULL;

    }

    else {

        return &mSessions[mSessions.Count() - 1];

    }

}