/*

* Copyright (c) 2006-2008 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:  CFContextSourceManager class implementation.

*

*/

#include <ecom/ecom.h>

#include <centralrepository.h>

#include <bautils.h>

#include <cfcontextsourceupgrade.h>

#include <cfcontextsourceinterface.h>

#include <cfcontextsourcecommand.h>

#include <cfcontextsubscriptionlistener.h>

#include "CFContextSourceManager.h"

#include "cfcontextsourcesettingsmanager.h"

#include "ContextFrameworkPrivateCRKeys.h"

#include "cfcontextsourceplugin.h"

#include "cfextendedcontextinterface.h"

#include "cfcontextsourcesettingarray.h"

#include "cftrace.h"

// CONSTANTS

const TInt KUIDNameStartPos = 1;

const TInt KUIDNameEndPos = 8;

// Drive letter hard coded since context source plug-in settings

// can only exist in ROM or RAM

_LIT( KSettingsPathRom, "Z:\\Private\\10282BC4\\Settings\\" );

_LIT( KSettingsPathRam, "C:\\Private\\10282BC4\\Settings\\" );

// Folder extension

_LIT( KFolderExt, "\\" );

// Setting file extension

_LIT( KSettingExtension, "*.xml" );

// Separates SID from filename for client installed settings

_LIT( KUnderscore, "_" );

/**

 * Information about a client acting as a context source.

 * This info is used to keep track of clients acting as context sources to

 * enable sending them context source commands.

 *

 * @lib CFContextSourceManager

 * @since S60 5.0

 */

NONSHARABLE_CLASS( TCFClientContextSourceInfo )

{

public: // Constructors

    TCFClientContextSourceInfo() : iSource( NULL ), iClientSid( KNullUid )

        {

        FUNC_LOG;

        }

    TCFClientContextSourceInfo( MCFContextSource* aSource, const TUid& aSid )

        :   iSource( aSource ), iClientSid( aSid )

        {

        FUNC_LOG;

        }

public: // Data

    /**

    * Context source interface pointer; not owned.

    */

    MCFContextSource* iSource;

    /**

    * Client's secure id (from client thread).

    */

    TUid iClientSid;

};

// ============================= LOCAL FUNCTIONS ==============================

/**

* Clenup operation for RImplInfoPtrArray

*/

LOCAL_C void CleanUpImplInfoArray( TAny* aParams )

    {

    RImplInfoPtrArray* array = static_cast<RImplInfoPtrArray*>( aParams );

    array->ResetAndDestroy();

    }

/**

* Push operations

*/

LOCAL_C void CleanupResetAndDestroyPushL( RImplInfoPtrArray& aArray )

    {

    TCleanupItem item( CleanUpImplInfoArray, &aArray );

    CleanupStack::PushL( item );

    }

/**

* Orders client countext source infos based on their uids.

* @param aFirst First context source info.

* @param aSecond Second context source info.

* @return Zero if the uid of the first and second are equal. Negative value

*   if the uid of the first is less than the uid of the second. Positive

*   value if the uid of the first is greater than the uid of the second.

*/

LOCAL_C TInt ClientContextSourceInfoUidOrder(

    const TCFClientContextSourceInfo& aFirst,

    const TCFClientContextSourceInfo& aSecond )

    {

    TInt orderValue = 1;

    if ( aFirst.iClientSid == aSecond.iClientSid )

        {

        orderValue = 0;

        }

    else if ( aFirst.iClientSid.iUid < aSecond.iClientSid.iUid )

        {

        orderValue = -1;

        }

    return orderValue;

    }

/**

* Context loader information.

*/

NONSHARABLE_CLASS( TCFLoaderInfo )

    {

    public:

    TCFLoaderInfo( CImplementationInformation& aImplementationInfo,

                   CCFContextSourceManager& aManager ):

                   iImplUid( aImplementationInfo.ImplementationUid() ),

                   iImplVersion( aImplementationInfo.Version() ),

                   iManager( aManager )

        {

        }

    public:

        TUid iImplUid;

        TInt iImplVersion;

        CCFContextSourceManager& iManager;

    };

/**

* Context source information.

*/

NONSHARABLE_CLASS( TCFContextSourceInfo )

    {

    public:

        TCFContextSourceInfo( CImplementationInformation& aImplInfo,

            CCFContextSourcePlugIn* aPlugIn ):

            iImplUid( aImplInfo.ImplementationUid() ), iImplVersion( aImplInfo.Version() ),

            iPlugIn( aPlugIn ), iMissing( ETrue )

            {

            }

    TCFContextSourceInfo( TUid aImplUid,

                          TInt aImplVersion,

                          CCFContextSourcePlugIn* aPlugIn ):

                          iImplUid( aImplUid ),

                          iImplVersion( aImplVersion ),

                          iPlugIn( aPlugIn ),

                          iMissing( ETrue )

        {

        }

    public:

        TUid iImplUid;

        TInt iImplVersion;

        CCFContextSourcePlugIn* iPlugIn;

        TBool iMissing;

    };

// ============================= MEMBER FUNCTIONS =============================

EXPORT_C CCFContextSourceManager* CCFContextSourceManager::NewL(

    MCFExtendedContextInterface& aCF,

    RFs& aFs )

    {

    FUNC_LOG;

    CCFContextSourceManager* self =

        CCFContextSourceManager::NewLC( aCF, aFs );

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C CCFContextSourceManager* CCFContextSourceManager::NewLC(

    MCFExtendedContextInterface& aCF,

    RFs& aFs )

    {

    FUNC_LOG;

    CCFContextSourceManager* self =

        new( ELeave ) CCFContextSourceManager( aCF, aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

EXPORT_C CCFContextSourceManager::~CCFContextSourceManager()

    {

    FUNC_LOG;

    iClientContextSources.Close();

    // Delete plug-ins

    TInt count = iPlugIns.Count();

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

        {

        CCFContextSourcePlugIn* plugIn = iPlugIns[i].iPlugIn;

        ReleasePlugIn( plugIn );

        }

    iPlugIns.Close();

    delete iSettingsManager;

    iLoaders.ResetAndDestroy();

    }

CCFContextSourceManager::CCFContextSourceManager(

    MCFExtendedContextInterface& aCF,

    RFs& aFs ):

    iCF( aCF ),

    iFs( aFs )

    {

    FUNC_LOG;

    // Nothing to do

    }

void CCFContextSourceManager::ConstructL()

    {

    FUNC_LOG;

    iSettingsManager = CCFContextSourceSettingsManager::NewL( iFs );

    }

void CCFContextSourceManager::SetEventHandler( MCFStarterEventHandler& aEventHandler )

    {

    FUNC_LOG;

	  iEventHandler = &aEventHandler;

    }

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

// CCFContextSourceManager::InstallSettingL

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

//

EXPORT_C void CCFContextSourceManager::InstallSettingL( RFile& aSettingFile,

    const TUid& aContextSourceUid,

    RThread& aClientThread )

    {

    FUNC_LOG;

    // Get plugin.

    MCFContextSourceUpgrade* sourceUpgrade = PlugInL( aContextSourceUid );

    // Parse setting file.

    CCFContextSourceSettingArray* settings

            = CCFContextSourceSettingArray::NewLC();    // CLEANUP<< settings

    RFile parseFile;

    User::LeaveIfError( parseFile.Duplicate( aSettingFile ) );

    // parseFile handle closed by the parser.

    iSettingsManager->ParseSettingsL( parseFile, *settings );

    // Check setting validity from plugin.

    TInt err = sourceUpgrade->CheckValidity( aClientThread, *settings );

    CleanupStack::PopAndDestroy( settings );            // CLEANUP>> settings

    ERROR( err, "CCFContextSourceManager::InstallSettingL - Context source CheckSecurity for new settings failed" );

    User::LeaveIfError( err );

    // Copy the setting file.

    CopySettingFileL( aSettingFile, aContextSourceUid, aClientThread );

    // Read all settings and give them to the plugin.

    CCFContextSourceSettingArray* settingArray

            = PlugInSettingsL( aContextSourceUid );

    // Ownership of settingArray is transferred to plugin.

    sourceUpgrade->UpdateSettingsL( settingArray );

    }

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

// CCFContextSourceManager::UninstallSettingL

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

//

EXPORT_C void CCFContextSourceManager::UninstallSettingL(

    const TDesC& aSettingFilename,

    const TUid& aContextSourceUid,

    RThread& aClientThread )

    {

    FUNC_LOG;

    // Get plugin.

    MCFContextSourceUpgrade* sourceUpgrade = PlugInL( aContextSourceUid );

    // Delete the setting file.

    DeleteSettingFileL( aSettingFilename, aContextSourceUid, aClientThread );

    // Read all settings and give them to the plugin.

    CCFContextSourceSettingArray* settingArray

            = PlugInSettingsL( aContextSourceUid );

    // Ownership of settingArray is transferred to plugin.

    sourceUpgrade->UpdateSettingsL( settingArray );

    }

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

// CCFContextSourceManager::UninstallSettingsL

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

//

EXPORT_C void CCFContextSourceManager::UninstallSettingsL(

    const TUid& aContextSourceUid,

    RThread& aClientThread )

    {

    FUNC_LOG;

    // Get plugin.

    MCFContextSourceUpgrade* sourceUpgrade = PlugInL( aContextSourceUid );

    // Delete all setting files installed by the client.

    DeleteSettingFileL( KSettingExtension, aContextSourceUid, aClientThread );

    // Read all settings and give them to the plugin.

    CCFContextSourceSettingArray* settingArray

            = PlugInSettingsL( aContextSourceUid );

    // Ownership of settingArray is transferred to plugin.

    sourceUpgrade->UpdateSettingsL( settingArray );

    }

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

// CCFContextSourceManager::HandleContextSourceCommandL

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

//

EXPORT_C void CCFContextSourceManager::HandleContextSourceCommandL(

    const CCFContextSourceCommand& aCommand )

    {

    FUNC_LOG;

    const TUid sourceUid = aCommand.SourceUid();

    // Find plugin.

    CCFContextSourcePlugIn* plugIn = NULL;

    for( TInt i = 0; i < iPlugIns.Count(); ++i )

        {

        if( iPlugIns[ i ].iImplUid == sourceUid )

            {

            plugIn = iPlugIns[ i ].iPlugIn;

            break;

            }

        }

    MCFContextSource* contextSource = NULL;

    if ( plugIn )

        {

        // Check plugin's support for MCFContextSource extension.

        contextSource = reinterpret_cast< MCFContextSource* >(

                plugIn->Extension( KCFContextSourceInterfaceUid ) );

        if ( !contextSource )

            {

            User::Leave( KErrExtensionNotSupported );

            }

        }

    else

        {

        TLinearOrder< TCFClientContextSourceInfo > uidOrder(

                ClientContextSourceInfoUidOrder );

        TCFClientContextSourceInfo clientInfo;

        clientInfo.iClientSid = sourceUid;

        TInt pos = iClientContextSources.FindInOrder( clientInfo, uidOrder );

        if ( pos == KErrNotFound )

            {

            User::Leave( KErrBadHandle );

            }

        contextSource = iClientContextSources[ pos ].iSource;

        }

    // Process source command

    if ( contextSource )

        {

        contextSource->HandleCommand( aCommand );

        }

    }

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

// CCFContextSourceManager::RegisterClientContextSource

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

//

EXPORT_C TInt CCFContextSourceManager::RegisterClientContextSource(

    MCFContextSource* aPublisher,

    const TUid& aPublisherUid )

    {

    FUNC_LOG;

    TLinearOrder< TCFClientContextSourceInfo > uidOrder(

            ClientContextSourceInfoUidOrder );

    TCFClientContextSourceInfo clientInfo( aPublisher, aPublisherUid );

    TInt err = iClientContextSources.InsertInOrder( clientInfo, uidOrder );

    if ( err == KErrAlreadyExists )

        {

        err = KErrNone;

        }

    ERROR( err, "CCFContextSourceManager::RegisterContextSourceClient - Failed" );

    return err;

    }

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

// CCFContextSourceManager::DeregisterClientContextSource

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

//

EXPORT_C void CCFContextSourceManager::DeregisterClientContextSource(

    const MCFContextSource& aPublisher )

    {

    FUNC_LOG;

    for ( TInt i = 0; i < iClientContextSources.Count(); ++i )

        {

        if ( &aPublisher == iClientContextSources[ i ].iSource )

            {

            iClientContextSources.Remove( i );

            break; // Stop, no duplicate entries are allowed.

            }

        }

    }

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

// CCFContextSourceManager::InitializePhaseL

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

//

void CCFContextSourceManager::InitializePhaseL(

    CCFPhaseBase::TCFPhaseId aPhase )

    {

    FUNC_LOG;

    switch( aPhase )

        {

        case CCFPhaseBase::ECFDeviceStarting:

            {

            InitDeviceStartingPhaseL();

            break;

            }

        case CCFPhaseBase::ECFLoadingPlugins:

            {

            InitLoadingPluginsPhaseL();

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CCFContextSourceManager::UpdatePlugInsL

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

//

void CCFContextSourceManager::UpdatePlugInsL()

	{

    FUNC_LOG;

	if (!iUpdatePluginsAllowed){return;}

    // List all plugins

    RImplInfoPtrArray implInfoArray;

    CleanupResetAndDestroyPushL( implInfoArray );

    REComSession::ListImplementationsL( KContextSourcePlugInInterface,

        implInfoArray );

    RemoveBlackListed( implInfoArray );

    // Check if the update is install or uninstall based

    TInt allCount = implInfoArray.Count();

    TInt loadedCount = iPlugIns.Count();

    INFO_1( "Found %d context source plug-in implementations from ecom", allCount );

    INFO_1( "%d context source plug-ins currently loaded", loadedCount );

    // Check if there were plugins installed

    if( allCount >= loadedCount )

        {

        for( TInt i = iPlugIns.Count() - 1; i >= 0; i-- )

            {

            TCFContextSourceInfo& pluginInfo = iPlugIns[i];

            for( TInt ii = 0; ii < implInfoArray.Count(); ii++ )

                {

                CImplementationInformation* implInfo = implInfoArray[ii];

                if( implInfo->ImplementationUid() == pluginInfo.iImplUid )

                    {

                    TInt oldVer = pluginInfo.iImplVersion;

                    TInt newVer = implInfo->Version();

                    // Check if the version has increased

                    if( newVer > oldVer )

                        {

                        // Delete old plugin

                        ReleasePlugIn( pluginInfo.iPlugIn );

                        iPlugIns.Remove( i );

                        // Clean up garbage

                        REComSession::FinalClose();

                        // Load the new version

                        TRAPD( err, LoadPluginL( implInfo->ImplementationUid(), implInfo->Version() ) );

                        ERROR_3( err, "Upgrade of new version of context source plugin [%x], oldVer: [%d], newVer: [%d] failed",

                            implInfo->ImplementationUid().iUid, oldVer, newVer );

                        if( err == KErrNone )

                            {

                            INFO_3( "Upgraded new version of context source plugin [%x], oldVer: [%d], newVer: [%d]",

                                implInfo->ImplementationUid().iUid, oldVer, newVer );

                            }

                        }