// Copyright (c) 2007-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          : CSIPClientResolver2.cpp
// Part of       : SIP Client Resolver
// Version       : 1.0
//



// INCLUDES
#include "CSIPClientResolver2.h"
#include "sipresolvedclient2.h"
#include "TSipClient.h"
#include "SIPCRLogs.h"
#include "sipclientresolverconfig.h"
#include "siprequest.h"
#include "sipuri.h"
#include "sipcodecutils.h"
#include "uricontainer.h"
#include "CleanupResetAndDestroy.h"
#include "CSipHeaderStrategyBase.h"

// ----------------------------------------------------------------------------
// CSIPClientResolver2::NewL
// ----------------------------------------------------------------------------
//
CSIPClientResolver2* CSIPClientResolver2::NewL ( CSIPRequest& aRequest )
    {
    SIP_CR_LOG("CSIPClientResolver2::NewL")
    CSIPClientResolver2* self = CSIPClientResolver2::NewLC ( aRequest );
    CleanupStack::Pop ( self );
    return self;
    }
    
// ----------------------------------------------------------------------------
// CSIPClientResolver2::NewLC
// ----------------------------------------------------------------------------
//
CSIPClientResolver2* CSIPClientResolver2::NewLC ( CSIPRequest& aRequest )
    {
    SIP_CR_LOG("CSIPClientResolver2::NewLC")
    CSIPClientResolver2* self = new( ELeave ) CSIPClientResolver2;
    CleanupStack::PushL( self );
    self->ConstructL( aRequest );
    return self;
    }
   
// ----------------------------------------------------------------------------
// CSIPClientResolver2::CSIPClientResolver2
// ----------------------------------------------------------------------------
//
CSIPClientResolver2::CSIPClientResolver2()
    {
    }

// ----------------------------------------------------------------------------
// CSIPClientResolver2::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPClientResolver2::ConstructL( CSIPRequest& aRequest )
    {
    iClientResolverConfig = CSipClientResolverConfig::NewL();
    UIDsForUserNameL( aRequest );
	LoadImplementationsL();
    }
    
// ----------------------------------------------------------------------------
// CSIPClientResolver2::~CSIPClientResolver2
// ----------------------------------------------------------------------------
//
CSIPClientResolver2::~CSIPClientResolver2 ()
    {
    SIP_CR_LOG("CSIPClientResolver2::~CSIPClientResolver2")
    iResolvedClients.ResetAndDestroy();
    iUids.Reset();
    iClientsData.Reset();
    delete iClientResolverConfig;
    }

// ----------------------------------------------------------------------------
// CSIPClientResolver2::ClientsData
// ----------------------------------------------------------------------------
//
RArray< TSipClient >& CSIPClientResolver2::ClientsData()
    {
    SIP_CR_LOG("CSIPClientResolver2::ClientsData")
    return iClientsData;
    }    
    
// ----------------------------------------------------------------------------
// CSIPClientResolver2::GetSipClientDataL
// ----------------------------------------------------------------------------
//
TBool CSIPClientResolver2::GetSipClientDataL( RArray< TSipClient >& aUids )
    {
    SIP_CR_LOG("CSIPClientResolver2::GetSipClientDataL")
    TBool found(EFalse);

    if ( iClientsData.Count() > 0 )
    	{
    	ListImplementationsL();
    	for( TInt i = 0; i < iClientsData.Count(); ++i )
    		{
        	TSipClient tmp = iClientsData[i];
        	if ( tmp.PluginType() == TSipClient::EFirstGeneration )
        		{
        		found = EFalse;
        		return found;
        		}
        	found = ETrue;
        	aUids.AppendL( tmp );
        	}
    	}
    SIP_CR_INT_LOG("CSIPClientResolver2::GetSipClientDataL count:",iUids.Count())
    return found;
    }   
        
 // ----------------------------------------------------------------------------
// CSIPClientResolver2::FetchMatchingUidsL
// ----------------------------------------------------------------------------
//
void CSIPClientResolver2::FetchMatchingUidsL( CSIPRequest& aRequest, 
								 			 CSipHeaderStrategyBase& aStrategy)
    {
    SIP_CR_LOG("CSIPClientResolver2::FetchMatchingUidsL")
    iClientsData.Reset();
    TBool match = EFalse;
    TUid clientUid;
    RPointerArray< CSIPResolvedClient2 > tempClients;
    CSIPClientResolver2::PushLC( &tempClients );
    for ( TInt i = iResolvedClients.Count()-1; i >= 0; --i )
        {
        CSIPResolvedClient2* client = iResolvedClients[i];
        match = aStrategy.MatchL( *client,aRequest,clientUid );
        if ( match )
            {
            SIP_CR_LOG("CSIPClientResolver2::FetchMatchingUidsL match")
            TSipClient temp( clientUid, client->ConnectSupported(), EFalse );
            temp.SetImplementationUid( client->iImplementationUid );
            iClientsData.AppendL( temp );
            match = EFalse;
            tempClients.AppendL( client );
            iResolvedClients.Remove( i );
            iResolvedClients.Compress();
            }
        }
    	 
    if ( tempClients.Count() )
    	{	
    	iResolvedClients.ResetAndDestroy();
    	for ( TInt i = tempClients.Count()-1; i >= 0; --i )
    		{
    		iResolvedClients.AppendL( tempClients[i] );
    		tempClients.Remove( i );
    		tempClients.Compress();
    		}
    	}	
    CleanupStack::Pop();//tempClients
    tempClients.Reset(); 
    }
    
// -----------------------------------------------------------------------------
// CSIPClientResolver2::PushLC
// -----------------------------------------------------------------------------
//
void CSIPClientResolver2::PushLC(RPointerArray<CSIPResolvedClient2>* aArray)
    {
	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArray,aArray));
    }
  
// -----------------------------------------------------------------------------
// CSIPClientResolver2::ResetAndDestroyArray
// -----------------------------------------------------------------------------
//
void CSIPClientResolver2::ResetAndDestroyArray(TAny* anArray)
	{
    RPointerArray<CSIPResolvedClient2>* array =
        reinterpret_cast<RPointerArray<CSIPResolvedClient2>*>(anArray);
    if (array)
        {
        array->ResetAndDestroy();
        }
	}    
  
// ----------------------------------------------------------------------------
// CSIPClientResolver2::Clients
// ----------------------------------------------------------------------------
//
RPointerArray< CSIPResolvedClient2 >& CSIPClientResolver2::Clients()
    {
    SIP_CR_LOG("CSIPClientResolver2::Clients")
    return iResolvedClients;
    }

// ----------------------------------------------------------------------------
// CSIPClientResolver2::UIDsForUserNameL
// ----------------------------------------------------------------------------
//
RArray <TUid> CSIPClientResolver2::UIDsForUserNameL( CSIPRequest& aRequest )
    {
    SIP_CR_LOG("CSIPClientResolver2::UIDsForUserNameL")
    iUids.Reset();
    if ( aRequest.RequestURI() )
    	{
    	if ( !aRequest.RequestURI()->IsSIPURI() )
    		{
    		User::Leave(KErrCorrupt);
    		}
    	iClientResolverConfig->GetUIDsForUserNameL(
    					aRequest.RequestURI()->SIPURI()->User(),iUids );
    	}
    SIP_CR_INT_LOG("CSIPClientResolver2::UIDsForUserNameL count:",iUids.Count())
    return iUids;
    }

// ----------------------------------------------------------------------------
// CSIPClientResolver2::ListImplementationsL
// ----------------------------------------------------------------------------
//
void CSIPClientResolver2::ListImplementationsL()
	{
	SIP_CR_LOG("CSIPClientResolver2::ListImplementationsL")
	RImplInfoPtrArray allClients;
    REComSession::ListImplementationsL( KSIPResolvedClient2IFUid, allClients );
    CleanupResetAndDestroyPushL( allClients );
    SIP_CR_INT_LOG("All new plug-ins count", allClients.Count())
    TInt err = KErrNone;

    for ( TInt i = 0; i < allClients.Count(); ++i )
	    {
	    CImplementationInformation* info = allClients[i];
	    TRAP(err,  AddClientDataL( *info ) );

	    if( err == KErrNoMemory )
            {
            User::Leave( err );
            }	    
	    }

    CleanupStack::PopAndDestroy( 1 ); // allClients
	}

// ----------------------------------------------------------------------------
// CSIPClientResolver2::AddClientDataL
// ----------------------------------------------------------------------------
//
void CSIPClientResolver2::AddClientDataL( CImplementationInformation& aInfo )
	{
	SIP_CR_LOG("CSIPClientResolver2::AddClientDataL")       
    for ( TInt i = 0; i < iClientsData.Count(); ++i ) 
    	{
    	if ( iClientsData[i].ImplementationUid() == aInfo.ImplementationUid() )
    		{
    		SIP_CR_LOG("CSIPClientResolver2::AddClientDataL check rombased")
    		iClientsData[i].SetRomBased( aInfo.RomBased() );
    		iClientsData[i].SetPluginType( TSipClient::ESecondGeneration );
    		return; 
    		}
    	}
	}
	
// ----------------------------------------------------------------------------
// CSIPClientResolver2::LoadImplementationsL
// ----------------------------------------------------------------------------
//
void CSIPClientResolver2::LoadImplementationsL()
	{
	SIP_CR_LOG("CSIPClientResolver2::LoadImplementationsL")
	CSIPResolvedClient2* resolvedClient2 = NULL;

	for ( TInt i = 0; i < iUids.Count(); ++i )
	    {
	    TRAPD( err, resolvedClient2 = reinterpret_cast< CSIPResolvedClient2* >( 
	        REComSession::CreateImplementationL( iUids[i],
	        			 _FOFF( CSIPResolvedClient2, iInstanceKey ) ) ) );
        if ( !err )
        	{
        	CleanupStack::PushL( resolvedClient2 );
        	resolvedClient2->iImplementationUid = iUids[i];
        	iResolvedClients.AppendL( resolvedClient2 );
        	CleanupStack::Pop( resolvedClient2 );
        	}
        err = 0;
	    }

	iUids.Reset();
	SIP_CR_INT_LOG("CSIPClientResolver2::LoadImplementationsL count:",
													iResolvedClients.Count())
	}


// End of File