/*
* Copyright (c) 2006-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:  An engine to collect context related metadata.
*
*/


// this class contains use of memory allocation and release not
// conforming to RAII principles

#include <e32uid.h>
#include <ecom.h>
#include <e32svr.h>

#include "contextengine.h"
#include "contextengineao.h"
#include "contextsnapshotitem.h"
#include "mdsutils.h"
#include "harvesterlog.h"
#include "harvesterdata.h"

/// Key for thread-local storage used by this singleton.
const TInt KContextEngineTLSKey = 0x200009f6;

// construct/destruct

// ---------------------------------------------------------------------------
// 1st phase C++ construction.
// Don't export these, because used only by our NewLC() and the like.
// ---------------------------------------------------------------------------
//
CContextEngine::CContextEngine( ) :
    iContextEngineAO( NULL ), iArrayCount( 0 ), iProcessedArrayCount( 0 )
    {
    WRITELOG( "CContextEngine::CContextEngine" ); // DEBUG INFO
    }

// ---------------------------------------------------------------------------
// 2nd phase construction
// ---------------------------------------------------------------------------
//
void CContextEngine::ConstructL( MContextInitializationObserver* aObserver )
    {
    WRITELOG( "CContextEngine::ConstructL" ); // DEBUG INFO
    iContextEngineAO = CContextEngineAO::NewL( aObserver, this );
    }

// ---------------------------------------------------------------------------
// Get a reference to this singleton. A new object is created if needed.
// If an observer object to notify is given, context plugins are initialized
// asyncronously and observer is notified when ready.
// ---------------------------------------------------------------------------
//
EXPORT_C CContextEngine* CContextEngine::GetInstanceL(
	MContextInitializationObserver* aObserver )
    {
    WRITELOG( "CContextEngine::GetInstanceL" ); // DEBUG INFO
    CContextEngineStaticData* data = static_cast<CContextEngineStaticData*>(
        UserSvr::DllTls(KContextEngineTLSKey) );
    CContextEngine* instance = NULL;
    if ( !data )
        {
        instance = new (ELeave) CContextEngine();
        CleanupStack::PushL( instance );
        instance->ConstructL( aObserver );

        UserSvr::DllSetTls( KContextEngineTLSKey,
        	new (ELeave) CContextEngineStaticData(instance) );

        CleanupStack::Pop( instance );
        }
    else
        {
        instance = data->iContextEngine;
        data->iRefCount++;
        if ( aObserver )
            {
            aObserver->ContextInitializationStatus( KErrNone );
            }
        }

    return instance;
    }

// ---------------------------------------------------------------------------
// Release a reference to this singleton.
// ---------------------------------------------------------------------------
//
EXPORT_C void CContextEngine::ReleaseInstance()
    {
    WRITELOG( "CContextEngine::ReleaseInstance" ); // DEBUG INFO
    CContextEngineStaticData* data =
        static_cast<CContextEngineStaticData*>( UserSvr::DllTls(KContextEngineTLSKey) );
    if ( data )
        {
        data->iRefCount--;
        if ( data->iRefCount <= 0 )
            {
            // destroy the singleton and free TLS
            delete data;
            UserSvr::DllFreeTls( KContextEngineTLSKey );
            }
        }
    }

/* ---------------------------------------------------------------------------
 * Ignores the reference count and destroys this singleton.            .   .
 * Should be used only if client code is not using ReleaseInstance()  /|\ /|\
 * to release their handles to this singleton.                         |   |
 *                                                                     |   |
 *                                                        			  -------
 *                                                                	  -------
 * ---------------------------------------------------------------------------
*/
EXPORT_C void CContextEngine::Destroy()
    {
    WRITELOG( "CContextEngine::Destroy" ); // DEBUG INFO
    CContextEngineStaticData* data =
        static_cast<CContextEngineStaticData*>( UserSvr::DllTls(KContextEngineTLSKey) );
    if ( data )
        {
        // destroy the singleton and free TLS
        delete data;
        UserSvr::DllFreeTls( KContextEngineTLSKey );
        }
    }

// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CContextEngine::~CContextEngine()
    {
    WRITELOG( "CContextEngine::~CContextEngine" ); // DEBUG INFO
    delete iContextEngineAO;

    MdsUtils::CleanupPtrArray<CContextSnapshotItem>( &iSnapshotQueue );
    REComSession::FinalClose(); // we are done
    }

// ---------------------------------------------------------------------------
// Set MdeSession to context engine and it's plugins.
// Session must be set in order to successfully harvest context data.
// ---------------------------------------------------------------------------
//
EXPORT_C void CContextEngine::SetMdeSession( CMdESession* aSession )
    {
    iContextEngineAO->SetMdeSession( aSession );
    }

// ---------------------------------------------------------------------------
// Takes a context snapshot including all initialized plugins.
// ---------------------------------------------------------------------------
//
EXPORT_C void CContextEngine::ContextSnapshot( MContextSnapshotObserver& aObserver,
    CHarvesterData& aHD )
    {
    WRITELOG( "CContextEngine::ContextSnapshot (single)" ); // DEBUG INFO
    
    // if any plug-in hasn't been found...
    if ( iContextEngineAO->PluginCount() <= 0 )
        {
        aHD.SetErrorCode( KErrNone );
        aObserver.ContextSnapshotStatus( &aHD );
        return;
        }

    // queue item for taking a snapshot
    CContextSnapshotItem* item = NULL;
    TRAPD( err, item = CContextSnapshotItem::NewL( &aObserver, &aHD ) );
    iArrayCount = 0;
    iProcessedArrayCount = 0;
    if ( err == KErrNone ) QueueSnapshotItem( item );
    }

// ---------------------------------------------------------------------------
// Takes a context snapshot including all initialized plugins
// for multiple objects.
// ---------------------------------------------------------------------------
//
EXPORT_C void CContextEngine::ContextSnapshot( MContextSnapshotObserver& aObserver,
    RPointerArray<CHarvesterData>& aHDArray )
    {
    WRITELOG( "CContextEngine::ContextSnapshot (array)" ); // DEBUG INFO
    
    // if any plug-in hasn't been found...
    if ( iContextEngineAO->PluginCount() <= 0 )
        {
        aObserver.ContextSnapshotStatus( NULL );
        return;
        }

    // queue items for taking a snapshot
    CContextSnapshotItem* item = NULL;
    TRAPD( err, item = CContextSnapshotItem::NewL( &aObserver, &aHDArray ) );
    iArrayCount = aHDArray.Count();
    iProcessedArrayCount = 0;
    if ( err == KErrNone ) QueueSnapshotItem( item );
    }

// ---------------------------------------------------------------------------
// Number of context plug-ins loaded. For testing purposes only.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CContextEngine::PluginCount()
    {
    return iContextEngineAO->PluginCount();
    }

// ---------------------------------------------------------------------------
// From MContextEngineObserver.
// Method is called by CContextEngineAO when a context snapshot is finished
// or an error has occured.
// ---------------------------------------------------------------------------
//
void CContextEngine::ContextSnapshotStatus( CHarvesterData* aHD )
    {
    if( iSnapshotQueue.Count() == 0 )
        {
        return;
        }
    
    if( iArrayCount > 0 )
        {
        iProcessedArrayCount++;
        }
    
    // notify the client application by using MContextSnapshotObserver's
    // method ContextSnapshotStatus()
    iSnapshotQueue[0]->GetObserver()->ContextSnapshotStatus( aHD );

    // remove handled item from queue
    if( iProcessedArrayCount == iArrayCount )
        {
        delete iSnapshotQueue[0];
        iSnapshotQueue[0] = NULL;
        iSnapshotQueue.Remove( 0 );
        iArrayCount = 0;
        iProcessedArrayCount = 0;
        }

    // ask a new snapshot if there is stuff in the queue
    if( iArrayCount == 0 && iSnapshotQueue.Count() > 0 )
        {
        RPointerArray<CHarvesterData>* tempArray = iSnapshotQueue[0]->GetItemArray();
        if( tempArray )
            {
            iArrayCount = tempArray->Count();
            }
        iContextEngineAO->StartSnapshot( iSnapshotQueue[0] );
        }
    else if( iSnapshotQueue.Count() == 0 )
    	{
    	iSnapshotQueue.Compress();
    	}
    }

// ---------------------------------------------------------------------------
// Add a new item to the snapshot item queue.
// Item contains an observer that needs to be informed when a snapshot is ready
// and items that need a context snapshot.
// If the queue was empty before adding the item, it's handling is started.
// ---------------------------------------------------------------------------
//
void CContextEngine::QueueSnapshotItem( CContextSnapshotItem* aItem )
    {
    // add a new object
    if ( iSnapshotQueue.Append( aItem ) != KErrNone )
        {
        delete aItem;
        return;
        }

    // the queue was empty, start ContextEngineAO
    if ( iSnapshotQueue.Count() == 1 )  // if the queue _was_ empty
        {
        iContextEngineAO->StartSnapshot( iSnapshotQueue[0] );
        }
    }