// Copyright (c) 2005-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:

// Name          : CSIPClientResolver.cpp

// Part of       : SIP Client Resolver

// Version       : 1.0

//

// INCLUDES

#include "CSIPClientResolver.h"

#include "sdpcodecstringpool.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "CSIPClientData.h"

#include "CSIPClientDataParser.h"

#include "CSipLaunchingStrategies.h"

#include "CleanupResetAndDestroy.h"

#include "SipResolvedClient.h"

#include "TSipClient.h"

#include "SIPCRLogs.h"

#include <e32math.h>

#include "CSIPClientResolver2.h"

_LIT(KWorkerThreadName, "SIPClientResolverWorker");

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

// CSIPClientResolver::NewLC

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

//

EXPORT_C CSIPClientResolver* CSIPClientResolver::NewL ()

    {

    CSIPClientResolver* self = new( ELeave ) CSIPClientResolver;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop (self);

    return self;

    }

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

// CSIPClientResolver::CSIPClientResolver

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

//

CSIPClientResolver::CSIPClientResolver()

    : CActive( CActive::EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CSIPClientResolver::ConstructL

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

//

void CSIPClientResolver::ConstructL()

    {

    SdpCodecStringPool::OpenL();

    iECom = &(REComSession::OpenL());

    // Create XML parser for SIP client data

    iClientDataParser = CSIPClientDataParser::NewL();

    // Create arrays

    iRegistry = new( ELeave )RPointerArray< CSIPClientData >;

    // Fill implementations registry

    ListImplementationsL();

    // Create strategies

    iLaunchingStrategies = CSipLaunchingStrategies::NewL( *this );

    // Request notification from ECom when plugin registry changes

    NotifyOnChange();

    }

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

// CSIPClientResolver::~CSIPClientResolver

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

//

EXPORT_C CSIPClientResolver::~CSIPClientResolver ()

    {

    delete iTmpPluginCaps;

    Cancel();

    delete iLaunchingStrategies;

    RemoveRegistry();

    delete iClientDataParser;

    if (iECom)

        {

        iECom->Close();

        }

    REComSession::FinalClose();

    SdpCodecStringPool::Close();

    }

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

// CSIPClientResolver::FindUidL

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

//

EXPORT_C CSIPResponse* CSIPClientResolver::FindUidL(

    const CSIPRequest& aRequest,

    RArray< TSipClient >& aUids )

    {

    SIP_CR_STR_LOG("CSIPClientResolver::FindUidL", aRequest.Method().DesC())

    CSIPRequest& request = const_cast<CSIPRequest&>( aRequest );

 	CSIPClientResolver2* clientresolver2 = NULL;

 	clientresolver2 = CSIPClientResolver2::NewLC(request);

    RefreshClientDataL();

    RArray< TUid > uids;

    CleanupClosePushL( uids );

    CopyAllUidsL ( uids );

    CSIPResponse* response = 

        iLaunchingStrategies->ApplyL( request, uids, *clientresolver2 );

    if( !response )

        {

        if ( !( clientresolver2 && 

        	    clientresolver2->GetSipClientDataL( aUids ) ) )

        	{

        	TInt uidCount = uids.Count();

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

            	{

            	MSipClient* client = GetByUID( uids[i] );

            	if( client )

                	{

                	TSipClient tmp( client->ClientUid(), 

                					client->AllowStarting(), 

                                	client->RomBased() );

                	aUids.AppendL( tmp );

                	}

            	}

        	}

        }

    else

        {

        SIP_CR_INT_LOG("CSIPClientResolver::FindUidL returns response",

                       response->ResponseCode())

        }    

	CleanupStack::PopAndDestroy(1); // uids

	CleanupStack::PopAndDestroy( clientresolver2 );

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

	    {

	    SIP_CR_INT_LOG("CSIPClientResolver::FindUidL matching client", 

	                   aUids[i].Uid().iUid)

	    }

	return response;

	}

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

// CSIPClientResolver::RefreshClientDataL

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

//

void CSIPClientResolver::RefreshClientDataL()

    {

    TInt err = KErrNone;

    TInt count = iRegistry->Count();

    for( TInt i = count-1; i >= 0; i-- )

        {

        CSIPClientData* client = (*iRegistry)[ i ];

        if( client->HasDynamicCapabilities() )

            {

            CSIPClientData* clone = client->CloneWithoutCapabilitiesLC();

            TRAP( err, ReloadClientDataL( *clone ) );

            if( err == KErrNone )

                {

                // Replace with the new client data

                (*iRegistry)[ i ] = clone;

                CleanupStack::Pop( clone );                

                }

            else if( err == KErrNoMemory )

                {

                User::Leave( err );

                }

            else

                {

                // Remove the invalid client

                iRegistry->Remove( i );

                CleanupStack::PopAndDestroy( clone );

                }

            delete client;

            }

        }    

    }	

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

// CSIPClientResolver::GetByUID

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

//

MSipClient* CSIPClientResolver::GetByUID( const TUid& aUid ) const

    {

    TInt count = iRegistry->Count();

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

        {

        MSipClient* client = (*iRegistry)[ i ];

        if( client->ClientUid() == aUid )

            {

            return client;

            }

        }

	return NULL;

    }

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

// CSIPClientResolver::DoCancel

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

//

void CSIPClientResolver::DoCancel()

    {

    iECom->CancelNotifyOnChange( iStatus );	

    }

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

// CSIPClientResolver::RunL

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

//

void CSIPClientResolver::RunL()

    {

    // Update implementations registry, fail silently

    TRAP_IGNORE( ListImplementationsL() )

    // Request further notification from ECom when plugin registry changes

    NotifyOnChange();

    }

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

// CSIPClientResolver::ListImplementationsL

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

//

void CSIPClientResolver::ListImplementationsL()

    {

    // Create a temporary array to avoid destroying 

    // an existing registry if we run out of memory

    RPointerArray< CSIPClientData >* tmpRegistry =

            new( ELeave ) RPointerArray< CSIPClientData >;

    CleanupStack::PushL( TCleanupItem( ResetAndDestroy, tmpRegistry ) );

    // ROM clients

    TEComResolverParams romResolverParams;

	RImplInfoPtrArray romClients;

	REComSession::ListImplementationsL( KSIPResolvedClientIFUid,

	                                    romResolverParams,

	                                    KRomOnlyResolverUid,

	                                    romClients );

    CleanupResetAndDestroyPushL( romClients );  

    ConvertClientDataL( romClients, *tmpRegistry, ETrue );

    SIP_CR_INT_LOG("ROM-based plug-ins count", romClients.Count())

    // RAM clients     

	RImplInfoPtrArray allClients;

	REComSession::ListImplementationsL( KSIPResolvedClientIFUid, allClients );

    CleanupResetAndDestroyPushL( allClients );

    SIP_CR_INT_LOG("All plug-ins count", allClients.Count())

    RemoveDuplicates( romClients, allClients );

    ConvertClientDataL( allClients, *tmpRegistry, EFalse );

    CleanupStack::PopAndDestroy( 1 ); // allClients

    CleanupStack::PopAndDestroy( 1 ); // romClients

    RemoveRegistry();

    delete iRegistry;

    iRegistry = tmpRegistry;

    CleanupStack::Pop( 1 ); // tmpRegistry

    }

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

// CSIPClientResolver::RemoveRegistry

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

//

void CSIPClientResolver::RemoveRegistry()

    {

    if( iRegistry )

        {

        iRegistry->ResetAndDestroy();

        delete iRegistry;

        iRegistry = NULL;

        }

    }

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

// CSIPClientResolver::NotifyOnChange

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

//

void CSIPClientResolver::NotifyOnChange()

    {

    iECom->NotifyOnChange( iStatus );

    SetActive();

    }

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

// CSIPClientResolver::CopyAllUidsL

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

//

void CSIPClientResolver::CopyAllUidsL ( RArray< TUid >& aUids )

    {

    TInt count = iRegistry->Count();

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

        {

        MSipClient* client = (*iRegistry)[ i ];

        aUids.AppendL( client->ClientUid() );	

        }

    }

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

// CSIPClientResolver::ConvertClientDataL

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

//

void CSIPClientResolver::ConvertClientDataL(

    const RImplInfoPtrArray& aImplInfo,

    RPointerArray< CSIPClientData >& aRegistry,

    TBool aRomClient )

    {

    TInt err = KErrNone;

    TInt clientCount = aImplInfo.Count();

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

        {

        // Ignore clients with invalid data

        CImplementationInformation* info = aImplInfo[ i ];

        TRAP( err, AddClientDataL( aRegistry, *info, aRomClient ) );

        SIP_CR_STR_LOG("Plug-in with 'default_data'", info->DataType())

        SIP_CR_INT_LOG("Plug-in status", err)

        if( err == KErrNoMemory )

            {

            User::Leave( err );

            }

        }      

    }

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

// CSIPClientResolver::AddClientDataL

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

//

void CSIPClientResolver::AddClientDataL( 

    RPointerArray< CSIPClientData >& aRegistry,

    CImplementationInformation& aInfo, 

    TBool aRomClient )

    {

	TLex8 lex( aInfo.DataType() );

    TUint32 uidValue( 0 );

    User::LeaveIfError( lex.Val( uidValue, EHex ) );

    TUid clientUid;

    clientUid.iUid = uidValue;     

    const TBool romBased = ( aRomClient && aInfo.RomBased() );

    TPtrC8 xml( aInfo.OpaqueData() );

    const TBool dynamicCaps = ( xml.Length() == 0 );

    CSIPClientData* clientData = 

        CSIPClientData::NewLC( aInfo.ImplementationUid(), clientUid,

                               romBased, dynamicCaps );    

    if ( !dynamicCaps )

        {

        // XML specified in resource-file.

        iClientDataParser->ParseL( clientData, xml );

        }

    aRegistry.AppendL( clientData );

    CleanupStack::Pop( clientData );

    }

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

// CSIPClientResolver::ReloadClientDataL

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

// 

void CSIPClientResolver::ReloadClientDataL( CSIPClientData& aClientData )

    {

    iTmpImplementationUid = aClientData.ImplementationUid();

    CreateWorkerThreadL();

    iClientDataParser->ParseL( &aClientData, *iTmpPluginCaps );

    delete iTmpPluginCaps;

    iTmpPluginCaps = NULL;

    }

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

// CSIPClientResolver::RemoveDuplicates

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

//

void CSIPClientResolver::RemoveDuplicates( 

    const RImplInfoPtrArray& aRomInfo,

    RImplInfoPtrArray& aAllInfo )

    {

    TInt romInfoCount = aRomInfo.Count();

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

        {

        for( TInt j=aAllInfo.Count()-1; j>=0; j-- )

            {

            CImplementationInformation* info = aAllInfo[j];

            if( info->ImplementationUid() == aRomInfo[i]->ImplementationUid() )

                {

                aAllInfo.Remove( j );

                delete info;

                }

            }

        }

    }

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

// CSIPClientResolver::ResetAndDestroy

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

//

void CSIPClientResolver::ResetAndDestroy( TAny* anArray )

    {

    RPointerArray< CSIPClientData >* array =

        reinterpret_cast<RPointerArray< CSIPClientData >*>( anArray );

    if (array)

        {

        array->ResetAndDestroy();

        delete array;

        }

    }

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

// CSIPClientResolver::CreateWorkerThreadL

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

//   

void CSIPClientResolver::CreateWorkerThreadL()

    {

    TName threadName(KWorkerThreadName);

    // Append a random number to make the name unique

    const TInt KThreadIdWidth = 10;

    threadName.AppendNumFixedWidthUC(Math::Random(), EHex, KThreadIdWidth);

    RThread thread;

    TInt err = thread.Create(threadName,

                             WorkerThreadFunction,

                             KDefaultStackSize,

                             NULL, // Use the same heap as the main thread

                             this);

    User::LeaveIfError(err);

    TRequestStatus status;

    thread.Logon(status);

    thread.Resume();

    User::WaitForRequest(status);

    TExitType exitType = thread.ExitType();

    thread.Close();

    if (exitType == EExitPanic)

        {

        User::Leave(KErrGeneral);

        }

    User::LeaveIfError(status.Int());

    }

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

// CSIPClientResolver::WorkerThreadFunction

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

//     

TInt CSIPClientResolver::WorkerThreadFunction(TAny* aPtr)

    {

    CSIPClientResolver* self = 

        reinterpret_cast<CSIPClientResolver*>(aPtr);

    TInt err = KErrNoMemory;

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if (cleanupStack)

        {

        TRAP(err, self->ReadPluginCapsL());

        REComSession::FinalClose(); // Needed for each thread separately

        }

    delete cleanupStack;

    return err;

    }

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

// CSIPClientResolver::ReadPluginCapsL

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

//  

void CSIPClientResolver::ReadPluginCapsL()

    {

    CSIPResolvedClient* plugin = 

        reinterpret_cast< CSIPResolvedClient* >( 

            REComSession::CreateImplementationL( 

                iTmpImplementationUid, 

                _FOFF( CSIPResolvedClient, iInstanceKey ) ) );

    CleanupStack::PushL( plugin );

    HBufC8* capsBuf = plugin->Capabilities().AllocL();

    CleanupStack::PopAndDestroy( plugin );

    delete iTmpPluginCaps;

    iTmpPluginCaps = capsBuf;

    }

// End of File