/*

* Copyright (c) 2006 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:   Describes a factory to return a handle to the Catalogs engine

*

*/

#include <e32base.h>

#include <e32property.h>

#include <ecom/ecom.h>

#include "catalogsengine.h"

#include "catalogsdebug.h"

#include "catalogserrors.h"

#include "catalogsconstants.h"

#ifndef CATALOGS_ECOM

static void CleanupMutex( TAny* aMutexPtr )

    {

    DLTRACEIN((""));

    RMutex* mutex = static_cast< RMutex* >( aMutexPtr );

    DLINFO(( "Signalling and closing engine mutex" ));

    mutex->Signal();

    mutex->Close();

    }

static void GetMutexLC( RMutex& aMutex )

    {

    DLTRACEIN((""));

    // First try to open the global mutex.

    DLINFO(( "Trying to open engine mutex" ));

    TInt mutexOpenErr = aMutex.OpenGlobal( KCatalogsEngineMutex );

    if( mutexOpenErr == KErrNotFound )

        {

        DLINFO(( "Mutex was not found, trying to create." ));

        mutexOpenErr = aMutex.CreateGlobal( KCatalogsEngineMutex );

        if( mutexOpenErr == KErrAlreadyExists )

            {

            // Someone beat us to it. Try opening again.

            DLINFO(( "Mutex was just created. Trying to open." ));

            mutexOpenErr = aMutex.OpenGlobal( KCatalogsEngineMutex );

            }

        }

    if( mutexOpenErr != KErrNone )

        {

        DLERROR(( "Mutex open failed with %d", mutexOpenErr ));

        DLTRACEOUT(( "LEAVE %d", mutexOpenErr ));

        User::Leave( mutexOpenErr );

        }

    DLINFO(( "Waiting for engine mutex..." ));

    aMutex.Wait();

    DLINFO(( "Got property mutex" ));

    // Push a cleanup item for signalling and closing the mutex.

    CleanupStack::PushL( TCleanupItem( CleanupMutex, &aMutex ) );

    DLTRACEOUT((""));

    }

static TBool IsMaintenanceLockOnL()

    {

    DLTRACEIN((""));

    // Get Catalogs Engine maintenance P&S variable

    DLINFO(( "Reading maintenance lock value" ));

    TInt value;

    TInt err = RProperty::Get( 

        KCatalogsEnginePropertyCategory, 

        KCatalogsEnginePropertyKeyMaintenanceLock,

        value );

    if( err == KErrNone )

        {

        DLINFO(( "Maintenance lock value %08x", value ));

        DLTRACEOUT(( "%d", value != 0 ));

        return value != 0;

        }

    else if( err != KErrNotFound )

        {

        DLERROR(( "Maintenance lock read failed with %d", err ));

        DLTRACEOUT(( "LEAVE %d", err )); 

        User::Leave( err );

        }

    // Maintenance P&S variable not set, not in maintenance mode.

    DLTRACEOUT(( "EFalse" ));

    return EFalse;

    }

static void SetMaintenanceLockL( TBool aLock )

    {

    DLTRACEIN(( "Writing %d to maintenance lock P&S", aLock ));

    // Write maintenance lock property.

    DLINFO(( "Writing maintenance lock property" ));

    TInt err = RProperty::Set(

        KCatalogsEnginePropertyCategory,

        KCatalogsEnginePropertyKeyMaintenanceLock,

        aLock );

    if( err == KErrNotFound )

        {

        DLINFO(( "Maintenance lock property not found, invoking server to define it" ));

        // P&S variable is defined in the server process. Connect to server to

        // accomplish this.

        MCatalogsEngineObserver* nullObserver = NULL;

        CCatalogsEngine* engine = CCatalogsEngine::NewLC( *nullObserver );

        err = engine->Connect( TUid::Uid( 0 ) );

        // Engine no longer needed, close, release and delete.

        DLINFO(( "Connect returned %d. Closing engine object.", err ));

        engine->Close();

        DLINFO(( "Deleting engine object" ));

        CleanupStack::PopAndDestroy( engine );

        if( err == KErrNone )

            {

            // The maintenance lock property should be defined now, try again.

            DLINFO(( "Writing maintenance lock property" ));

            err = RProperty::Set(

                KCatalogsEnginePropertyCategory,

                KCatalogsEnginePropertyKeyMaintenanceLock,

                aLock );

            }

        }

    if( err != KErrNone )

        {

        DLERROR(( "Maintenance lock set failed, error %d", err ));

        DLTRACEOUT(( "LEAVE %d", err ));

        User::Leave( err );

        }

    DLTRACEOUT((""));

    }

EXPORT_C CCatalogsEngine::TState CCatalogsEngine::StateL()

    {

    DLTRACEIN((""));

    RMutex mutex;

    GetMutexLC( mutex );

    TState result = EStateNormal;

    if( IsMaintenanceLockOnL() )

        {

        // Either EStatePrepareMaintenance or EStateMaintenance.

        DLINFO(( "Maintenance lock is on." ));

        // Check if engine instances exist. This can be determined by mutex usage:

        // all existing instances hold a handle to the mutex. If there are handles

        // in addition to the one held here, other instances exist.

        THandleInfo mutexHandleInfo;

        mutex.HandleInfo( &mutexHandleInfo );

        DLINFO(( "Mutex handle in-process count %d, process count %d",

            mutexHandleInfo.iNumOpenInProcess, mutexHandleInfo.iNumProcesses ));

        if( mutexHandleInfo.iNumOpenInProcess > 1 || 

            mutexHandleInfo.iNumProcesses > 1 )

            {

            result = EStatePrepareMaintenance;

            }

        else

            {

            result = EStateMaintenance;

            }

        }

    CleanupStack::PopAndDestroy();  // mutex Signal() and Close()

    DLTRACEOUT(( "%d", result ));

    return result;

    }

/**

 * Instantiates the catalogs engine, using the maintenance lock to determine

 * if instantiation is allowed.

 */

EXPORT_C CCatalogsEngine* CCatalogsEngine::NewLC( MCatalogsEngineObserver& aObserver )

    {

    DLTRACEIN(( "aObserver=%08x", &aObserver ));

    // Get/create Catalogs Engine maintenance lock mutex

    RMutex mutex;

    GetMutexLC( mutex );

    if( IsMaintenanceLockOnL() )

        {

        DLWARNING(( "Catalogs Engine in maintenance mode, cannot create engine instance" ));

        DLTRACEOUT(( "LEAVE KCatalogsErrorMaintenanceMode" ));

        User::Leave( KCatalogsErrorMaintenanceMode );

        }

    // Not in maintenance mode, ok to instantiate engine class. Do this before releasing the

    // mutex, as this may define the maintenance lock P&S.

    DLINFO(( "Creating ECom object with UID %08x", KCCatalogsEngineImplUid.iUid ));

    CCatalogsEngine* object = 0;

    TRAPD( err,

        {

        object = reinterpret_cast< CCatalogsEngine* >( 

            REComSession::CreateImplementationL( 

                KCCatalogsEngineImplUid, _FOFF(CCatalogsEngine,iDtor_ID_Key), &aObserver ) );

        }); //TRAPD

    DLINFO(("ECom creation err=%d",err));

    User::LeaveIfError( err );

    DLINFO(( "ECom returned pointer %08x", object ));

    DASSERT( object != NULL );

    CleanupStack::PopAndDestroy(); // mutex signal & close

    CleanupStack::PushL( object );

    DLTRACEOUT(( "%08x", object ));

    return object;

    }

EXPORT_C CCatalogsEngine* CCatalogsEngine::NewL( MCatalogsEngineObserver& aObserver )

    {

    DLTRACEIN(( "aObserver=%08x", &aObserver ));

    CCatalogsEngine* engine = CCatalogsEngine::NewLC( aObserver );

    CleanupStack::Pop();

    DLTRACEOUT(( "%08x", engine ));

    return engine;

    }

EXPORT_C void CCatalogsEngine::StartMaintenanceL()

    {

    DLTRACEIN((""));

    // Get Catalogs Engine maintenance lock mutex

    RMutex mutex;

    GetMutexLC( mutex );

    if( IsMaintenanceLockOnL() )

        {

        DLERROR(( "Engine already locked for maintenance mode" ));

        DLTRACEOUT(( "LEAVE KErrAlreadyExists" ));

        User::Leave( KErrAlreadyExists );

        }

    // Set the maintenance lock. This will send a P&S event to any existing

    // engine instances and create a callback for the clients.

    SetMaintenanceLockL( ETrue );

    CleanupStack::PopAndDestroy();  // mutex signal & close

    }

EXPORT_C void CCatalogsEngine::EndMaintenanceL()

    {

    // Get Catalogs Engine maintenance lock mutex

    DLTRACEIN((""));

    RMutex mutex;

    GetMutexLC( mutex );

    if( !IsMaintenanceLockOnL() )

        {

        DLERROR(( "Maintenance lock not on" ));

        DLTRACEOUT(( "LEAVE KCatalogsErrorMaintenanceNotStarted" ));

        User::Leave( KCatalogsErrorMaintenanceNotStarted );

        }

    SetMaintenanceLockL( EFalse );

    CleanupStack::PopAndDestroy();  // mutex signal & close

    }

#endif // CATALOGS_ECOM

/**

 * Destructor

 */

CCatalogsEngine::~CCatalogsEngine()

    {

    DLTRACEIN(( "this=%08x", this ));

    REComSession::DestroyedImplementation( iDtor_ID_Key );

    // Is it ok to say FinalClose() even if engine object instances exist? Should be, hope so.

    // FinalClose not okay, from help: "It must never be called from within a plugin class destructor."

    //DLTRACE(("FinalClose()"));

    //REComSession::FinalClose();

    DLTRACEOUT(( "this=%08x", this ));

    }

/**

 * Constructor

 */

CCatalogsEngine::CCatalogsEngine()

    {

    }