// Copyright (c) 2004-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        : CProxyQuery.cpp
// Part of     : ProxyResolver
// Version     : SIP/4.0
//



#include "CProxyQuery.h"
#include "MSIPProxyResolverObserver.h"
#include "MQueryObserver.h"
#include <utf.h>
#include <nifman.h>


const TInt CProxyQuery::iOffset = _FOFF(CProxyQuery, iLink);

// -----------------------------------------------------------------------------
// CProxyQuery::NewL
// -----------------------------------------------------------------------------
//
CProxyQuery* CProxyQuery::NewL( TUint                      aRequestId, 
                                TUint32                    aIAPId,
                                MSIPProxyResolverObserver& aResolverObserver,
                                MQueryObserver&            aQueryObserver,
                                RSocketServ&               aServer )
    {
    CProxyQuery* self = CProxyQuery::NewLC( aRequestId, 
                                            aIAPId, 
                                            aResolverObserver, 
                                            aQueryObserver, 
                                            aServer );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CProxyQuery::NewLC
// -----------------------------------------------------------------------------
//
CProxyQuery* CProxyQuery::NewLC( TUint                      aRequestId,
                                 TUint32                    aIAPId,
                                 MSIPProxyResolverObserver& aResolverObserver,
                                 MQueryObserver&            aQueryObserver,
                                 RSocketServ&               aServer )
    {
    CProxyQuery* self = new( ELeave )CProxyQuery( aRequestId,
                                                  aIAPId,
                                                  aResolverObserver,
                                                  aQueryObserver,
                                                  aServer );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }
    
// -----------------------------------------------------------------------------
// CProxyQuery::~CProxyQuery
// -----------------------------------------------------------------------------
//  
CProxyQuery::~CProxyQuery ()
    {
    delete iConnCont;    
    delete iResultsArray;
    }

// -----------------------------------------------------------------------------
// CProxyQuery::Connection()
// returns the RConnection object
// -----------------------------------------------------------------------------
//  
RConnection & CProxyQuery::Connection() 
    {  
    return iConnCont->Connection(); 
    }
    
// -----------------------------------------------------------------------------
// CProxyQuery::ConnectionOpened()
// returns connection opening status
// -----------------------------------------------------------------------------
//  
TBool CProxyQuery::ConnectionOpened()     
    { 
    return iConnectionOpened;   
    }

// -----------------------------------------------------------------------------
// CProxyQuery::ConstructL
// -----------------------------------------------------------------------------
// 
void CProxyQuery::ConstructL()
    {
    iConnCont = CProxyConnectionContainer::NewL( *this, iIAPId, iServer );   
    iSipServerAddrBuf().index = 0;  
    iSipServerDomainBuf().index = 0;  
    iCurrentQueryType = KConnGetSipServerDomain;
    iResultsArray = new (ELeave) CDesC8ArrayFlat(1);    
    }
    
// -----------------------------------------------------------------------------
// CProxyQuery::CProxyQuery
// -----------------------------------------------------------------------------
//
CProxyQuery::CProxyQuery( TUint                        aRequestId,
                          TUint32                      aIAPId, 
                          MSIPProxyResolverObserver&   aResolverObserver,
                          MQueryObserver&              aQueryObserver,
                          RSocketServ&                 aServer )
    :   iRequestId( aRequestId ),
        iIAPId( aIAPId ),
        iResolverObserver( aResolverObserver ),
        iQueryObserver( aQueryObserver ),
        iConnectionOpened( EFalse ),
        iServer( aServer )
    {
    }

// -----------------------------------------------------------------------------
// CProxyQuery::ResolvingRequestComplete
// -----------------------------------------------------------------------------
//
void CProxyQuery::ResolvingRequestComplete()
    {
    if ( iResultsArray->Count() > 0 )
        {
        iResolverObserver.ProxyResolvingRequestComplete( iRequestId, 
                                                         iResultsArray ); 
        iResultsArray = NULL; // ownership transferred       
        }
    else
        {
        ResolvingRequestFailed( KErrNotFound );
        }
    }
    
// -----------------------------------------------------------------------------
// CProxyQuery::ResolvingRequestFailed
// -----------------------------------------------------------------------------
//
void CProxyQuery::ResolvingRequestFailed( TInt aError )
    {
    iResolverObserver.ProxyResolvingRequestFailed( iRequestId, aError );
    }

// -----------------------------------------------------------------------------
// CProxyQuery::RequestId
// -----------------------------------------------------------------------------
//
TUint CProxyQuery::RequestId() const
    {
    return iRequestId;
    }
    
// -----------------------------------------------------------------------------
// CProxyQuery::IAPId
// -----------------------------------------------------------------------------
//
TUint32 CProxyQuery::IAPId() const
    {
    return iIAPId;
    }

// -----------------------------------------------------------------------------
// CProxyQuery::ConnectionReady
// -----------------------------------------------------------------------------
//
void CProxyQuery::ConnectionReady()
    {
    iConnectionOpened = ETrue;
    iQueryObserver.ConnectionReady(this);    
    }

// -----------------------------------------------------------------------------
// CProxyQuery::ErrorOccured
// -----------------------------------------------------------------------------
//
void CProxyQuery::ErrorOccured( TInt aError )
    {
    iConnectionOpened = EFalse;   //just to be sure..
    iQueryObserver.ErrorOccured( aError, this );
    }


// -----------------------------------------------------------------------------
// CProxyQuery::CurrentQueryType
// -----------------------------------------------------------------------------
//
TUint CProxyQuery::CurrentQueryType()
    {
    return iCurrentQueryType;
    }
    
// -----------------------------------------------------------------------------
// CProxyQuery::SetQueryType
// -----------------------------------------------------------------------------
//
void CProxyQuery::SetQueryType( TUint aNewType )
    {    
    iCurrentQueryType = aNewType;
    }            

// -----------------------------------------------------------------------------
// CProxyQuery::SetNextIndex
// -----------------------------------------------------------------------------
//
void CProxyQuery::SetNextIndex()
    {
    if ( iCurrentQueryType == KConnGetSipServerAddr )
        {        
	    (iSipServerAddrBuf().index)++;
        }
    else
        {
	    (iSipServerDomainBuf().index)++;
        }
    }            

// -----------------------------------------------------------------------------
// CProxyQuery::GetBuf
// -----------------------------------------------------------------------------
//
TDes8* CProxyQuery::GetBuf()
    {
    if ( iCurrentQueryType == KConnGetSipServerAddr )
        {        
	    return &iSipServerAddrBuf;
        }
    else
        {
        return &iSipServerDomainBuf;            
        }
    }            
   
// -----------------------------------------------------------------------------
// CProxyQuery::AddResultsL
// -----------------------------------------------------------------------------
//
void CProxyQuery::AddResultsL()
    {
    THostName addr;
    if ( iCurrentQueryType == KConnGetSipServerAddr )
        {
        iSipServerAddrBuf().address.Output( addr );    
	     
        }        
    else
        {
        addr.Copy( iSipServerDomainBuf().domainName );
        }
        
    HBufC8* addrBuf = HBufC8::NewLC( 2*addr.Length() );
    TPtr8 addrBufPtr = addrBuf->Des();
    User::LeaveIfError( 
        CnvUtfConverter::ConvertFromUnicodeToUtf8( addrBufPtr, addr ) );   
    if ( addrBufPtr.Length() > 0 )
        {
        iResultsArray->AppendL( addrBufPtr );   	                   	
        }
    CleanupStack::PopAndDestroy( addrBuf );
    }