/*

* 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 <tswindowgroupsobserver.h>

#include "tstaskmonitorglobals.h"

#include "hsrunningappserver.h"

#include "hsrunningappsession.h"

#include "tsbacksteppingactivation.h"

#include "tsmodel.h"

#include "tsstorage.h"

#include "tsservicesprovider.h"

#include "tsserializeddataprovider.h"

#include "tsrunningappmodel.h"

_LIT(KErrObserverExists, "Observer already exists");

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

//

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

//

CRunningAppServer::CRunningAppServer()

:

CServer2(EPriorityStandard)

{

    // No implementation required

}

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

//

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

//

CRunningAppServer::~CRunningAppServer()

{

    delete mBacksteppingEngine;

    delete mStorage;

    delete mAppsModel;

    delete mServiceProvider;

    delete mSerializer;

    delete mMonitor;

    mObservers.ResetAndDestroy();

}

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

//

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

//

CRunningAppServer* CRunningAppServer::NewLC()

{

    CRunningAppServer* self = new (ELeave) CRunningAppServer();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

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

//

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

//

void CRunningAppServer::ConstructL()

{

    StartL(KRunningAppServerName);

    User::LeaveIfError(mWsSession.Connect());

    mResources = CTsResourceManager::NewL();

    mMonitor = CTsWindowGroupsMonitor::NewL(*mResources);

    mSerializer = CTsSerializedDataProvider::NewL(*this);

    RPointerArray<MTsModel> providers;

    CleanupClosePushL(providers);

    mAppsModel = CTsRunningAppModel::NewL(*mResources, *mMonitor);

    providers.AppendL(mAppsModel);

    CTsServiceProviderConfig *cfg = CTsServiceProviderConfig::NewLC();

    mServiceProvider = CTsServiceProvider::NewL(*cfg);

    CleanupStack::PopAndDestroy(cfg);

    addProviders(providers, *mServiceProvider);

    mStorage = CTsStorage::NewL(providers.Array());

    mStorage->setObserver(mSerializer);

    CleanupStack::PopAndDestroy(&providers);

    // load initial data

    mStorage->DataChanged();

    TRAP_IGNORE(mBacksteppingEngine = CTsBacksteppingActivation::NewL(*mMonitor);)

}

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

//

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

//

CSession2* CRunningAppServer::NewSessionL(const TVersion &, const RMessage2&) const

{

    RPointerArray<MTsDataStorage> dataStorages;

    CleanupClosePushL(dataStorages);

    dataStorages.AppendL(const_cast<CRunningAppServer *>(this)->mAppsModel);

    dataStorages.AppendL(const_cast<CRunningAppServer *>(this)->mStorage);

    CSession2* retVal = CRunningAppSession::NewL(*const_cast<CRunningAppServer *>(this),

                                                 *const_cast<CRunningAppServer *>(this)->mSerializer,

                                                 dataStorages.Array());

    CleanupStack::PopAndDestroy(&dataStorages);

    return retVal;

}

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

//

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

//

void CRunningAppServer::DataChanged()

{

    while (0 < mObservers.Count()) {

        mObservers[0]->DataChanged();

    }

}

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

//

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

//

void CRunningAppServer::PushL(CTsDataObserver* observer)

{

    ( 0 <= mObservers.Find(observer)) ?

    User::Panic(KErrObserverExists, KErrAlreadyExists) :

    mObservers.AppendL(observer);

}

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

//

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

//

void CRunningAppServer::Pop(CTsDataObserver* observer)

{

    const TInt offset(mObservers.Find(observer));

    if(0 <= offset) {

        mObservers.Remove(offset);

    }

}

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

//

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

//

void CRunningAppServer::Cancel(const RMessage2& reason)

{

    for (TInt iter(mObservers.Count() - 1); 0 <= iter; --iter) {

        mObservers[iter]->Cancel(reason);

    }

    reason.Complete(KErrNone);

}

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

//

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

//

void CRunningAppServer::Invalidate(const CSession2* session)

{

    for (TInt iter(mObservers.Count() - 1); 0 <= iter; --iter) {

        if(mObservers[iter]->IsParent(session)) {

            delete mObservers[iter];

            mObservers.Remove(iter);

        }

    }

}

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

void CRunningAppServer::addProviders(RPointerArray<MTsModel> &dst, 

                                     const CTsServiceProvider& serviceProvider)

{

    for (TInt offset(0); offset < serviceProvider.count(); ++offset) {

        dst.Append(&serviceProvider[offset]);

    }

}