/*
* 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:  IMPS Protocol implementation for Presence Framework
*
*/


#include <badesca.h>
#include <ecom/implementationproxy.h>

#include <ximpserviceinfo.h>
#include <ximpbase.h>
#include <ximpidentity.h>
#include <presenceinfo.h>
#include <ximpprotocolconnectionhost.h>
#include <FeatMgr.h>
#include <bldvariant.hrh>
#include "CImpsPlugin.h"
#include "ImpsDebugPrint.h"
#include "CImpsConnection.h"
#include "impsplugin12uid.h"
#include "ximpcontextclientinfo.h"

_LIT( KImpsPlugin, "CImpsPlugin" );

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


// ---------------------------------------------------------------------------
// Key value pair table to identify correct constructor
// function for the requested interface.
// ---------------------------------------------------------------------------
//
const TImplementationProxy ImplementationTable[] =
    {
    IMPLEMENTATION_PROXY_ENTRY( KImps12PluginAdaptationUid3, CImpsPlugin::NewL )
    };


// ---------------------------------------------------------------------------
// Exported function to return the implementation proxy table
// ---------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )
    {
    IMPS_DP( D_IMPS_LIT( "ImplementationGroupProxy() Start" ) );

    aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );
    IMPS_DP( D_IMPS_LIT( "ImplementationGroupProxy() End" ) );

    return ImplementationTable;
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::CImpsPlugin()
// ---------------------------------------------------------------------------
//
CImpsPlugin::CImpsPlugin()
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::CImpsPlugin() Start-End" ) );
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::ConstructL()
// ---------------------------------------------------------------------------
//
void CImpsPlugin::ConstructL()
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::ConstructL() Start-End" ) );

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdPresence ) &&
         FeatureManager::FeatureSupported( KFeatureIdPresenceFramework ) &&
         FeatureManager::FeatureSupported( KFeatureIdIm )  )
        {
        //construct the plugin
        }
    else
        {
        IMPS_DP( D_IMPS_LIT( "CImpsPlugin::ConstructL() Feature Not Supported" ) );
        User::Leave( KErrNotSupported );
        }

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::ConstructL() End" ) );
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::NewLC()
// ---------------------------------------------------------------------------
//
CImpsPlugin* CImpsPlugin::NewLC()
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::NewLC() Start" ) );

    CImpsPlugin* self = CImpsPlugin::NewL();
    CleanupStack::PushL( self );

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::NewLC() End" ) );
    return self;
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::NewL()
// ---------------------------------------------------------------------------
//
CImpsPlugin* CImpsPlugin::NewL()
    {
    IMPS_DP( D_IMPS_LIT( "=============================START=========================================" ) );
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::NewL() Start" ) );

    CImpsPlugin* self = new( ELeave ) CImpsPlugin();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::NewL() End :Address of %d" ), &self );
    return self;
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::CImpsPlugin()
// ---------------------------------------------------------------------------
//
CImpsPlugin::~CImpsPlugin()
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::~CImpsPlugin() Start" ) );
    FeatureManager::UnInitializeLib();

    iConnections.ResetAndDestroy();

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::~CImpsPlugin() End" ) );
    IMPS_DP( D_IMPS_LIT( "=============================END=========================================" ) );
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::PrimeHost()
// ---------------------------------------------------------------------------
//
void CImpsPlugin::PrimeHost( MXIMPProtocolPluginHost& aHost )
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::PrimeHost() Start" ) );

    iHost = &aHost;

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::PrimeHost() End" ) );
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::AcquireConnectionL()
// ---------------------------------------------------------------------------
//
MXIMPProtocolConnection& CImpsPlugin::AcquireConnectionL(
    const MXIMPServiceInfo& aServiceInfo,
    const MXIMPContextClientInfo& aClientCtxInfo )
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::AcquireConnectionL() Start" ) );

    CImpsConnection* connection = CImpsConnection::NewL( aServiceInfo, aClientCtxInfo );

    IMPS_DP( D_IMPS_LIT( " CImpsPlugin::AcquireConnectionL:service address::%S" ), &( aServiceInfo.ServiceAddress() ) );
    IMPS_DP( D_IMPS_LIT( " CImpsPlugin::AcquireConnectionL:user ID::%S" ), &( aServiceInfo.UserId() ) );
    IMPS_DP( D_IMPS_LIT( " CImpsPlugin::AcquireConnectionL:user password::%S" ), &( aServiceInfo.Password() ) );
    IMPS_DP( D_IMPS_LIT( " CImpsPlugin::AcquireConnectionL:Client ID::%S" ), &( aClientCtxInfo.ClientId().Identity() ) );
    CleanupStack::PushL( connection );
    iConnections.AppendL( connection );
    CleanupStack::Pop( connection );

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::AcquireConnectionL() End" ) );
    return *connection;
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::ReleaseConnection()
// ---------------------------------------------------------------------------
//
void CImpsPlugin::ReleaseConnection( MXIMPProtocolConnection& aConnection )
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::ReleaseConnection() Start" ) );

    TInt connectionsCount = iConnections.Count();

    for ( TInt i( connectionsCount - 1 ); i >= 0; i-- )
        {
        MXIMPProtocolConnection* tmp = iConnections[i];
        if ( tmp == &aConnection )
            {
            delete iConnections[i];
            iConnections.Remove( i );
            }
        }

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::ReleaseConnection() End" ) );
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::GetInterface()
// ---------------------------------------------------------------------------
//
TAny* CImpsPlugin::GetInterface( TInt32 aInterfaceId,
                                 TIfGetOps aOptions  )
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::GetInterface() Start" ) );

    if ( aInterfaceId == MXIMPProtocolPlugin::KInterfaceId )
        {
        MXIMPProtocolPlugin* self = this;
        return self;
        }

    if ( aOptions == MXIMPBase::EPanicIfUnknown )

        {
        User::Panic( KImpsPlugin, KErrExtensionNotSupported );
        }

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::GetInterface() End" ) );
    return NULL;
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::GetInterface()
// ---------------------------------------------------------------------------
//
const TAny* CImpsPlugin::GetInterface( TInt32 aInterfaceId,
                                       TIfGetOps aOptions ) const
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::GetInterface() const Start" ) );

    if ( aInterfaceId == MXIMPProtocolPlugin::KInterfaceId )
        {
        const MXIMPProtocolPlugin* self = this;
        return self;
        }

    if ( aOptions == MXIMPBase::EPanicIfUnknown )

        {
        User::Panic( KImpsPlugin, KErrExtensionNotSupported );
        }

    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::GetInterface() const End" ) );

    return NULL;
    }


// ---------------------------------------------------------------------------
// CImpsPlugin::GetInterfaceId()
// ---------------------------------------------------------------------------
//
TInt32 CImpsPlugin::GetInterfaceId() const
    {
    IMPS_DP( D_IMPS_LIT( "CImpsPlugin::GetInterface() without parameters Start-End" ) );
    return MXIMPProtocolPlugin::KInterfaceId;
    }


// End of file