/*

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

#include "tsstorage.h"

#include "tsmodelitemkeymsg.h"

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

/**

 * Two phase construction. Create and initialize storage instance.

 * @param aDataProviders - list of data providers

 * @return storage instane

 */

CTsStorage* CTsStorage::NewL(const TArray<MTsModel*> &aDataProviders)

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aDataProviders );

    CleanupStack::Pop( self );

    return self;

    }

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

/**

 * Destructor. Function cancel subscribtion for data change notyfications

 */

CTsStorage::~CTsStorage()

    {

    for( TInt iter(0); iter < iDataProviders.Count(); ++iter )

        {

        iDataProviders[iter]->SetObserver( 0 );

        }

    iData.Close();

    }

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

/**

 * First phase construction.

 */

CTsStorage::CTsStorage()

    {

    //No implementation required

    }

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

/**

 * Second phase construction. Function make subscribtion for data changes notifications

 * @param aDataProviders - list of data providers

 */

void CTsStorage::ConstructL( const TArray<MTsModel*> &aDataProviders )

    {

    for (TInt iter(0); iter < aDataProviders.Count(); ++iter)

        {

        iDataProviders.AppendL( aDataProviders[iter] );

        aDataProviders[iter]->SetObserver( this );

        }

    }

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

/**

 * Interface implementation

 * @see MTsDataObserver::DataChanged()

 */

void CTsStorage::DataChanged()

    {

    ResetModel();

    }

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

TBool CTsStorage::IsSupported( TInt aFunction ) const

    {

    return ( OpenTaskMessage == aFunction || CloseTaskMessage == aFunction );

    }

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

void CTsStorage::HandleDataL( TInt aFunction, RReadStream& aDataStream )

    {

    if( !IsSupported(aFunction) ) 

        {

        User::Leave( KErrCorrupt );

        }

    CTsModelItemKeyMsg* msg = CTsModelItemKeyMsg::NewLC( aDataStream );

    OpenTaskMessage == aFunction ? LaunchL( msg->Key() ) : CloseL( msg->Key() );

    CleanupStack::PopAndDestroy( msg );

    }

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

/**

 * Interface implementation

 * @see MTsModelObserver::dataChanged(MTsModel &)

 */

void CTsStorage::DataChanged(MTsModel &/*model*/)

    {

    ResetModel();

    }

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

/**

 * Interface implementation

 * @see MTsModel::count()

 */

TInt CTsStorage::Count() const

    {

    return iData.Count();

    }

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

/**

 * Interface implementation

 * @see MTsModel::SetObserver(MTsModelObserver *)

 */

void CTsStorage::SetObserver( MTsModelObserver* aObserver ) 

    {

    iDataObserver = aObserver;

    }

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

/**

 * Interface implementation

 * @see MTsModel::DisplayNameL(TInt)

 */

const TDesC& CTsStorage::DisplayNameL( TInt aOffset ) const 

    {

    return iData[aOffset].DisplayNameL();

    }

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

/**

 * Interface implementation

 * @see MTsModel::IconHandleL(TInt)

 */

TInt CTsStorage::IconHandleL( TInt aOffset ) const 

    {

    return iData[aOffset].IconHandleL();

    }

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

/**

 * Interface implementation

 * @see MTsModel::TimestampL(TInt)

 */

TTime CTsStorage::TimestampL( TInt aOffset ) const 

    {

    return iData[aOffset].TimestampL();

    }

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

/**

 * Interface implementation

 * @see MTsModel::TimestampUpdateL(TInt)

 */

TTime CTsStorage::TimestampUpdateL( TInt offset ) const 

{

    return iData[offset].TimestampUpdateL();

}

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

/**

 * Interface implementation

 * @see MTsModel::KeyL(TInt)

 */

TTsModelItemKey CTsStorage::KeyL( TInt aoffset ) const 

    {

    return iData[aoffset].KeyL();

    }

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

/**

 * Interface implementation

 * @see MTsModel::IsActiveL(TInt)

 */

TBool CTsStorage::IsActiveL( TInt aOffset ) const 

    {

    return iData[aOffset].IsActiveL();

    }

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

/**

 * Interface implementation

 * @see MTsModel::IsClosableL(TInt)

 */

TBool CTsStorage::IsClosableL( TInt aOffset ) const 

    {

    return iData[aOffset].IsClosableL();

    }

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

/**

 * Interface implementation

 * @see MTsModel::CloseL(TTsModelItemKey)

 */

TBool CTsStorage::CloseL( TTsModelItemKey aKey ) const 

    {

    return FindL(aKey).CloseL();

    }

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

/**

 * Interface implementation

 * @see MTsModel::launchL(TTsModelItemKey)

 */

TBool CTsStorage::LaunchL(TTsModelItemKey aKey) const 

    {

    return FindL(aKey).LaunchL(); 

    }

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

TTsModelItem CTsStorage::FindL( TTsModelItemKey aKey ) const

    {

    for( TInt offset(0); offset < iData.Count(); ++offset ) 

        {

        if( iData[offset].KeyL() == aKey )

            {

            return iData[offset];

            }

        }

    User::Leave(KErrNotFound);

    return ItemL(0);//just avoid compilation warnings

    }

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

/**

 * Retrieve shallow copy of data from known data providers and sort entries

 */

TInt CTsStorage::ResetModel()

    {

    TRAPD(errNo, ResetModelL());

    return errNo;

    }

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

/**

 * Retrieve shallow copy of data from known data providers and sort entries

 */

void CTsStorage::ResetModelL() 

    {

    iData.Reset();

    for(TInt iter(0); iter < iDataProviders.Count(); ++iter )

        {

        PullDataL(*(iDataProviders[iter]));

        }

    ReorderDataL();

    if (0 != iDataObserver)

        {

        iDataObserver->DataChanged(*this);

        }

    }

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

/**

 * Retrieve shallow copy of data from source model

 * @param aSrc - source model 

 */

void CTsStorage::PullDataL( const MTsModel& aSrc )

    {

    for( TInt iter(0); iter < aSrc.Count(); ++iter )

        {

        iData.AppendL(aSrc.ItemL(iter));

        }

    }

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

/**

 * Sort internal data model 

 */

void CTsStorage::ReorderDataL()

    {

    for( TInt prev(0); prev < iData.Count(); ++prev ) 

        {

        for( TInt next(prev + 1); next < iData.Count(); ++next )

            {

            const TTsModelItem prevItem(iData[prev]), nextItem(iData[next]);

            if( prevItem.TimestampL() < nextItem.TimestampL() )

                {

                iData.Remove(prev);

                iData.InsertL(nextItem, prev);

                iData.Remove(next);

                iData.InsertL(prevItem, next);

                }

            }

        }

    }