/*

* Copyright (c) 2002 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: 

*     Produces objects that implement MLogsModel

*

*/

// INCLUDE FILES

#include "CLogsModel.h"

#include "MLogsReader.h"

#include "MLogsEvent.h"

#include "MLogsStateHolder.h"

#include "CLogsEventGetter.h"

#include "CLogsReaderFactory.h"

#include "CLogsGetEventFactory.h"

#include "MLogsEventArray.h"

// CONSTANTS

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

// CLogsModel::NewL

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

//

CLogsModel* CLogsModel::NewL( 

    RFs& aFsSession,

    TLogsModel aModel,

    TLogsEventStrings& aStrings,

    CLogsEngine* aLogsEngineRef )

    {

    CLogsModel* self = new (ELeave) CLogsModel( aFsSession, aModel, aStrings, aLogsEngineRef );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CLogsModel::CLogsModel

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

//

CLogsModel::CLogsModel( 

    RFs& aFsSession,

    TLogsModel aModel,

    TLogsEventStrings& aStrings,

    CLogsEngine* aLogsEngineRef ) :

        iFsSession( aFsSession ),

        iModel( aModel ), 

        iStrings( aStrings ),

        iState( EStateUndefined ),

        iLogsEngineRef( aLogsEngineRef )     

    {

    }

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

// CLogsModel::ConstructL

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

//

void CLogsModel::ConstructL()

    {

    iEventArray = CLogsGetEventFactory::LogsEventArrayL( iModel, 20 );

    iWrapper = CLogsEventGetter::NewL();    

    }

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

// CLogsModel::~CLogsModel

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

//

CLogsModel::~CLogsModel()

    {

    if( iEventArray )

        {

        iEventArray->Reset();

        }

    delete iEventArray;

    delete iWrapper;

    delete iReader;

    }

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

// CLogsModel::Delete

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

//

void CLogsModel::Delete( TInt aIndex )

	{

	iEventArray->Delete( aIndex );

	}

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

// CLogsModel::Count

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

//

TInt CLogsModel::Count()

    {

    return iEventArray->Count();

    }

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

// CLogsModel::KickStartL

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

//

void CLogsModel::KickStartL( TBool aReset )

    {

    if( iObserver && iEventArray && aReset )              

        {

        iState = EStateInitializing; //This informs observers that e.g. a complete re-read of recent events is about to begin

                                     // so that they can e.g. change their view focus settings accordingly

                                     // (e.g. CLogsRecentListView::StateChangedL ).

        iEventArray->Reset();        //Delete the old rows as it might take too long to read the new correct contents

        iObserver->StateChangedL( this );

        }

    if( iReader )

        {

        // call ActivateL first, cause KickStartL is called directly from CLogsEngine too

        iReader->ActivateL();  

        iReader->StartL();

        }

    }

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

// CLogsModel::At

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

//

const MLogsEventGetter* CLogsModel::At( TInt aIndex )

    {

    if( aIndex < 0 || aIndex >= Count() )

        {

        iWrapper->Wrap( NULL );

        return NULL;

        }

    return iWrapper->Wrap(&iEventArray->At( aIndex ) );  //Log events in iEventArray 

    }

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

// CLogsModel::SetObserver

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

//

void CLogsModel::SetObserver( MLogsObserver* aObserver )

    {

    iObserver = aObserver;

    }

//This function can be called several times without calling DoDeactivate between calls

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

// CLogsModel::DoActivateL

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

//

void CLogsModel::DoActivateL( TDoActivate aDoActivate )

    {

    if( !iReader )

        {

        TRAPD( err, iReader = CLogsReaderFactory::LogsReaderL( iFsSession, 

                                        *iEventArray, iStrings, iModel, this, iLogsEngineRef ) );

		if( err == KErrAccessDenied )

			{

			delete iReader;

			iReader = NULL;

			return;

			}

        User::LeaveIfError(err);

        }

    iReader->ActivateL();  //This needs to be done before any other iReader call

    //Update list only if refresh requested, otherwise leave as it is

    if( aDoActivate != EActivateOnly )

        {

        if( iReader->IsDirty() )

            {

            //ETrue: reset list before reading

            KickStartL( aDoActivate == EResetAndRefresh ? ETrue : EFalse );

            }

        else if( iReader->IsInterrupted() )

            {

            iReader->ContinueL();

            }

        }        

    }

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

// CLogsModel::DoDeactivate

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

//

void CLogsModel::DoDeactivate( 

    TClearMissedCalls aClearMissedCalls,

    TDoDeactivate aDisconnectDb )

    {

    if( iModel == ELogsMissedModel && 

        aClearMissedCalls == ENormalOperation ) 

        {

        if( iReader ) 

            {

            TInt count(iEventArray->Count());

            for(TInt i = 0; i < count; i++)

                {

                iEventArray->At(i).SetDuplicates(0);

                }

            //We need to clear duplicates from the db too

            TInt err;        

            TRAP( err, iReader->ClearDuplicatesL() );

            }

        }

    /**************************************************************************************************        

     * This did not help enough for EMSH-6JDFBV, therefore original below still in use.

    //if( aDisconnectDb ) //Needs to be done always, otherwise happened a bit too late when MT call is received.

        {

        //iReader->Stop(); //This seems to be not enough for EMSH-6JDFBV, two rows below work a bit better instead

        iReader->Interrupt();   

        iReader->DeActivate( ); 

        }

    **************************************************************************************************/

    //For main model we cannot delete the reader, otherwise the use must wait long for the lines to show up again 

    //in the event view. Also we cannot update the view in CLogsEventListView::StateChangedL too frequently when the 

    //model is being reread. 

    if( iModel == ELogsMainModel )

        {

        if( iReader )

            {

            iReader->DeActivate();

            iReader->Interrupt();

            }

        }

    else

        {

        if( aDisconnectDb == ECloseDBConnectionAndResetArray ||

            aDisconnectDb == ECloseDBConnection )

            {

            //The rows below stop effectively cpu and I/O consumption in view of EMSH-6JDFBV. However, 

            //they also kill user's perceived UI responsiviness so aDisconnectDb should be used sparingly. 

            //Because reader may be deleted when reading of db is ongoing, we need also explicitly inform 

            //observer that we are finished.

            delete iReader; 

            iReader = NULL; 

            iState = EStateReaderDeletedOrStopped; 

            if (aDisconnectDb == ECloseDBConnectionAndResetArray)

                {

                iState = EStateArrayReseted; 

                iEventArray->Reset();  

                }  

            if( iObserver )

                {

                TInt err;        

                TRAP( err, iObserver->StateChangedL( this ) );

                }

            }

        // Special case, just reset the array. This is needed to avoid flicker of 

        // old list since reread of events is done when regaining foreground

        else if (aDisconnectDb == EResetOnlyArray || aDisconnectDb == EResetOnlyArrayWithDirty )

            {

            iState = EStateArrayReseted;

            iEventArray->Reset(); 

            if ( aDisconnectDb == EResetOnlyArrayWithDirty )

                {

                if( iReader )

                    {

                    iReader->SetDirty();

                    }              

                }

            if( iObserver )

                {

                TInt err;        

                TRAP( err, iObserver->StateChangedL( this ) );

                }

            }

        }

    }

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

// CLogsModel::Reset

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

//

void CLogsModel::Reset()

    {

    iWrapper->Wrap( NULL );

    }

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

// CLogsModel::State

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

//

TLogsState CLogsModel::State() const

    {

    return iState;

    }

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

// CLogsModel::ConfigureL

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

//

void CLogsModel::ConfigureL( const MLogsReaderConfig* aConfig )

    {

    if( iReader )

        {

        iReader->Stop();

        iReader->ConfigureL( aConfig );

        KickStartL( ETrue );

        }

    } 

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

// CLogsModel::StateChangedL

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

//

void CLogsModel::StateChangedL( MLogsStateHolder* aHolder )

    {

    if( aHolder->State() == EStateClearLogFinished )

        {

        KickStartL( ETrue );

        }

/*

    if( aHolder->State() == EStateFreeToDelete )

        {

        delete iReader;

        iReader = NULL;

        }

    else

*/    

        {

        iState = aHolder->State();

        if( iObserver )

            {

            iObserver->StateChangedL( this );

            }

        }

    }