/*
* 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:  Implementation of class CPEngPlgSrv
*
*/


//  Include Files
#include "CPEngPlgSrv.h"
#include "CPEngPlgSess.h"
#include "PresenceDebugPrint.h"
#include "TPEngServerParams.h"
#include "CPEngPluginHolder.h"
#include "CPEngPluginInterface2.h"
#include <e32svr.h>
#include <s32file.h>
#include <sysutil.h>
#include <ecom/ecom.h>

// simple wrapper class with array deletion on close
class RImplInfoPtrArray2 : public RImplInfoPtrArray
    {
    public:
        void Close()
            {
            ResetAndDestroy();
            }
    };

// Static data for Capability check configuration
// Two ranges: one for allowed, second for disallowed requests
static const TInt KPEngPluginServerRangeCount = 2;

/**
 * Ranges for the Request values
 * All requests will fall in one range
 */
static const TInt PEngPluginServerRanges[KPEngPluginServerRangeCount] =
    {
    // Range from EPEngPlgShutdownServer to EPEngPlgServerLastRequest
    0,
    // range is from EPEngPlgServerLastRequest request to end
    EPEngPlgServerLastRequest
    };

/**
 * Element indexes for the defined ranges
 * we have only one range and for it is defined only one Element
 */
static const TUint8 KPEngPluginServerElementsIndex[KPEngPluginServerRangeCount] =
    {
    // First element in the element array will be applied for this range
    0,
    // the second element will be used for the second range
    CPolicyServer::ENotSupported
    };

// Policy elements
static const CPolicyServer::TPolicyElement KPEngPluginServerElements[] =
    {
        {
        _INIT_SECURITY_POLICY_C3( ECapabilityReadUserData,
        ECapabilityWriteUserData,
        ECapabilityNetworkServices ),
        CPolicyServer::EFailClient
        }
    };

// and the Policy array is the following
static const CPolicyServer::TPolicy KPEngPluginServerPolicy =
    {
    // The index into Elements,that is used to check a connection attempt
    0,
    // Number of ranges in the iRanges array
    KPEngPluginServerRangeCount,
    // A pointer to an array of ordered ranges of request numbers
    PEngPluginServerRanges,
    // A pointer to an array of TUint8 values specifying
    // the appropriate action to take for each range in iRanges
    KPEngPluginServerElementsIndex,
    // A pointer to an array of distinct policy elements
    KPEngPluginServerElements
    };

// CONSTRUCTION
// Static constructor, leaves pointer to cleanup-stack
CPEngPlgSrv* CPEngPlgSrv::NewLC( const TDesC& aServerName, TInt aPriority )
    {
    CPEngPlgSrv* self = new( ELeave ) CPEngPlgSrv( aPriority );
    CleanupStack::PushL( self );
    self->ConstructL( aServerName );
    return self;
    }

// Destructor (virtual by CBase)
CPEngPlgSrv::~CPEngPlgSrv()
    {
    iPlugins.ResetAndDestroy();
    REComSession::FinalClose();
    }

// Default constructor, protected
CPEngPlgSrv::CPEngPlgSrv( TInt aPriority )
        : CPolicyServer( aPriority, KPEngPluginServerPolicy ),
        iOnlineState( EPEngPlgSvrStateUnknown )
    {
    }

// Second phase construct
void CPEngPlgSrv::ConstructL( const TDesC& aServerName )
    {
    iServerName.Copy( aServerName );
    StartL( aServerName );
    }


TInt CPEngPlgSrv::ExecuteServerL( TPEngServerParams& aParams )
    {
    __UHEAP_MARK;

    //Renaming must be done as early as possible
    aParams.RenameMainThread( KPEngPluginServerExe );

    TInt res( KErrNone );

    // start scheduler and server
    CActiveScheduler* pA = new( ELeave )CActiveScheduler;
    CleanupStack::PushL( pA );
    CActiveScheduler::Install( pA );

    //If exe server, call RunServerL directly.
    TRAP( res, RunServerL( aParams ) );

    CActiveScheduler::Install( NULL );
    CleanupStack::PopAndDestroy();//pA

    __UHEAP_MARKEND;
    return res;
    }

void CPEngPlgSrv::StopServer()
    {
    CActiveScheduler::Stop(); // CSI: 4 #
    }


void CPEngPlgSrv::RunServerL( TPEngServerParams& aParams )
    {
    PENG_DP( D_PENG_LIT( "CPEngPlgSrv::RunServerL()" ) );

    //One instance of server must be allocated here.
    CPEngPlgSrv* server = CPEngPlgSrv::NewLC( aParams.ServerName(),
                                              CActive::EPriorityStandard );

    aParams.Signal();
    // start fielding requests from clients
    //Thread is ended when CActiveScheduler::Stop is called.
    server->StartServer();

    CleanupStack::PopAndDestroy();//server
    // finished
    }

void CPEngPlgSrv::LoadByTypeL( const TDesC8& aPluginType )
    {
    PENG_DP( D_PENG_LIT( "CPEngPlgSrv::LoadByTypeL" ) );

    RImplInfoPtrArray2 plugins;
    CleanupClosePushL( plugins );

    TEComResolverParams params;
    params.SetDataType( aPluginType );
    params.SetWildcardMatch( EFalse );
    REComSession::ListImplementationsL( KPEngPluginInterfaceUid, params, plugins );

    const TInt count = plugins.Count();

    for ( TInt i( 0 ); i < count; i++ )
        {
        TUid uid = plugins[i]->ImplementationUid();

        CPEngPluginHolder* plug = CPEngPluginHolder::NewLC();
        plug->LoadPluginL( uid );
        iPlugins.AppendL( plug );

        CleanupStack::Pop();//plug
        }

    CleanupStack::PopAndDestroy();  // plugins

    PENG_DP( D_PENG_LIT( "CPEngPlgSrv::LoadByTypeL ends" ) );
    }

void CPEngPlgSrv::UnloadOnlinePluginsL()
    {
    PENG_DP( D_PENG_LIT( "CPEngPlgSrv::UnloadOnlinePluginsL" ) );
    RImplInfoPtrArray2 plugins;
    CleanupClosePushL( plugins );

    TEComResolverParams params;
    params.SetDataType( KPEngOnlineType );
    params.SetWildcardMatch( EFalse );
    REComSession::ListImplementationsL( KPEngPluginInterfaceUid, params, plugins );

    const TInt implCount = plugins.Count();
    for ( TInt ii( implCount - 1 ); ii >= 0; ii-- )
        {
        const TInt loadedCount = iPlugins.Count();
        for ( TInt jj( loadedCount - 1 ); jj >= 0; jj-- )
            {
            if ( plugins[ii]->ImplementationUid() == iPlugins[jj]->Uid() )
                {
                delete iPlugins[ jj ];
                iPlugins.Remove( jj );
                }
            }
        }

    CleanupStack::PopAndDestroy();  // plugins

    PENG_DP( D_PENG_LIT( "CPEngPlgSrv::UnloadOnlinePluginsL ends" ) );
    }

void CPEngPlgSrv::UnloadAllL()
    {
    iPlugins.ResetAndDestroy();
    }

void CPEngPlgSrv::SetStateL( TPEngPlgOnlineState aNewState )
    {
    if ( iOnlineState < EPEngPlgSvrStateOnline &&
         aNewState == EPEngPlgSvrStateOnline )
        {
        // we went online, load online plugins
        LoadByTypeL( KPEngOnlineType );
        }
    if ( aNewState == EPEngPlgSvrStateOffline &&
         iOnlineState == EPEngPlgSvrStateOnline )
        {
        // we went offline, unload and load offline plugins
        UnloadOnlinePluginsL();
        }
    if ( aNewState == EPEngPlgSvrStateOffline &&
         iOnlineState == EPEngPlgSvrStateUnknown )
        {
        // the server was first started and we are offline
        LoadByTypeL( KPEngOfflineType );
        }
    if ( aNewState == EPEngPlgSvrStateUnknown )
        {
        // this shouldn't happen in normal situations
        UnloadAllL();
        }

    iOnlineState = aNewState;
    }

TInt CPEngPlgSrv::PluginCount() const
    {
    return iPlugins.Count();
    }

TInt CPEngPlgSrv::Plugin( TInt aIndex ) const
    {
    return iPlugins[aIndex]->Uid().iUid;
    }

void CPEngPlgSrv::StartServer()
    {
    CActiveScheduler::Start(); // CSI: 3 #
    }

CSession2* CPEngPlgSrv::NewSessionL( const TVersion &aVersion, const RMessage2& /*aMessage*/ ) const
    {
    if ( !User::QueryVersionSupported( aVersion, TVersion( KRequiredVersionMajor, KRequiredVersionMinor, KRequiredVersionBuild ) ) )
        {
        User::Leave( KErrNotSupported );
        }

    return CPEngPlgSess::NewL( const_cast<CPEngPlgSrv&>( *this ) );
    };

//  End of File