/*
* 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:  Capability resolver implementation
*
*/


// INCLUDE FILES
#include "BTServiceUtils.h"
#include "BTSUCapabilityResolver.h"
#include "BTSUDebug.h"
#include <utf.h>


// CONSTANTS

_LIT8( KBTSUImageTag, "image-formats" );
_LIT8( KBTSUAttributeEncoding, "encoding" );
_LIT8( KBTSUAttributePixel, "pixel" );
_LIT8( KBTSUAttributeMaxSize,"maxsize");
_LIT(minus,"-");
_LIT(star,"*");




#define  INVALIDVALUE   -1
// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CBTSBIPController::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CBTSUCapabilityResolver* CBTSUCapabilityResolver::NewL(CDesCArrayFlat* aCapabilityList)
    {
    CBTSUCapabilityResolver* self = new( ELeave ) CBTSUCapabilityResolver( aCapabilityList );
    CleanupStack::PushL( self );
    self->ConstructL(  );
    CleanupStack::Pop(self);
    return self;
    }
    
// -----------------------------------------------------------------------------
// CBTSBIPController::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CBTSUCapabilityResolver* CBTSUCapabilityResolver::NewL(RArray<TBTSUImageCap>* aCapabilityList)
    {
    CBTSUCapabilityResolver* self = new( ELeave ) CBTSUCapabilityResolver( aCapabilityList );
    CleanupStack::PushL( self );
    self->ConstructL(  );
    CleanupStack::Pop(self);
    return self;
    }
// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::CBTSUCapabilityResolver
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CBTSUCapabilityResolver::CBTSUCapabilityResolver( CDesCArrayFlat* aCapabilityList )
	{	
	aCapabilityList=aCapabilityList;
	}
// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::CBTSUCapabilityResolver
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//	
CBTSUCapabilityResolver::CBTSUCapabilityResolver( 
    RArray<TBTSUImageCap>* aCapabilityList ) : iCapabilityList( aCapabilityList )
    {
    }
    
// -----------------------------------------------------------------------------
// CBTSBIPController::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CBTSUCapabilityResolver::ConstructL ()
    {
    }   
  
// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CBTSUCapabilityResolver::~CBTSUCapabilityResolver()
    {
    }

// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::StartDocument
// -----------------------------------------------------------------------------
//
void CBTSUCapabilityResolver::OnStartDocumentL(const Xml::RDocumentParameters& /*aDocParam*/, TInt aErrorCode)
    {
    FLOG(_L("[BTSU]\t CBTSUCapabilityResolver::OnStartDocumentL()"));
    if(aErrorCode!=KErrNone)
        {
        FLOG(_L("[BTSU]\t Error OnStartDocument"));            
        }    
    iCompleted=EFalse;
    }

// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::EndDocument
// -----------------------------------------------------------------------------
//
void CBTSUCapabilityResolver::OnEndDocumentL(TInt aErrorCode)
    {
    FLOG(_L("[BTSU]\t CBTSUCapabilityResolver::OnEndDocumentL()"));
    if(aErrorCode!=KErrNone)
        {
        FLOG(_L("[BTSU]\t Error EndDocument"));            
        }            
    }

// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::StartElement
// -----------------------------------------------------------------------------
//
void CBTSUCapabilityResolver::OnStartElementL(const Xml::RTagInfo& aElement, const Xml::RAttributeArray& aAttributes, 
								 TInt /*aErrorCode*/)  
    {    
 
    TBool status = EFalse;
    TBTSUImageCap param;
    TLex lex;
    TPtrC sizemaxwidth;
    TPtrC sizemaxheight;
    TPtrC sizeminwidth;
    TPtrC sizeminheight;
    TPtrC sizemin;
    TPtrC sizemax;	
    TInt index;
    HBufC* enc;	 
    param.iMaxByteSize=0;                

    TBuf<KBTSUMaxStringLength> conversionBuf;
    
    if( aElement.LocalName().DesC() != KBTSUImageTag )
        {        
        return;
        }
    
  
    if(aAttributes.Count()>0)
        {		
	
        param.iEncoding=NULL; 
        param.iMaxByteSize=-1;
        param.iMinPixelSize.iHeight=INVALIDVALUE;
        param.iMinPixelSize.iWidth=INVALIDVALUE;		 
        param.iMaxPixelSize.iWidth=INVALIDVALUE;
        param.iMaxPixelSize.iHeight=INVALIDVALUE;
		 
    	//Check and add to attribute list if there is encoding    	    	    	
        for ( TInt iCounter = 0 ; iCounter < aAttributes.Count() ; iCounter++ )
            {
            if ( aAttributes[iCounter].Attribute().LocalName().DesC() == KBTSUAttributeEncoding )
                {                              
                User::LeaveIfError( CnvUtfConverter::ConvertToUnicodeFromUtf8( conversionBuf, aAttributes[iCounter].Value().DesC()));                                                    
                
                if (conversionBuf.Length()>0)
                    {	                                        		
                    enc=conversionBuf.Alloc();
                    TPtr rwdata(enc->Des());     
                    rwdata.Copy(conversionBuf);                 
                    param.iEncoding=enc;         	                    
                    if (param.iEncoding!=NULL)
                    	{                    	
                    	status=ETrue;
                    	}         		
                    }
                }
            }          			
       	conversionBuf = KNullDesC;
        for ( TInt iCounter = 0 ; iCounter < aAttributes.Count() ; iCounter++ )        
            {                
            if ( aAttributes[iCounter].Attribute().LocalName().DesC() == KBTSUAttributePixel )
                {                    ;
                User::LeaveIfError( CnvUtfConverter::ConvertToUnicodeFromUtf8( conversionBuf, aAttributes[iCounter].Value().DesC()));
                }
            }            
            
		if(conversionBuf.Length()>1)
			{				
			index=conversionBuf.Find(minus);	
			if(index!=KErrNotFound) //max size is given
				{					
				sizemin.Set(conversionBuf.Left(index));					
				sizemax.Set(conversionBuf.Right(conversionBuf.Length()-index-1));
				//solve min size
				index=sizemin.Find(star); 	
				if(index!=KErrNotFound)
					{
					sizeminwidth.Set(sizemin.Left(index));
					sizeminheight.Set(sizemin.Right(sizemin.Length()-index-1));
													
					lex.Assign(sizeminwidth);
					lex.Val(param.iMinPixelSize.iHeight);
						
					lex.Assign(sizeminheight);
					lex.Val(param.iMinPixelSize.iWidth);						
					}
				//solve max size	
				index=sizemax.Find(star);	
				if(index!=KErrNotFound)
					{
					sizemaxwidth.Set(sizemax.Left(index));
					sizemaxheight.Set(sizemax.Right(sizemax.Length()-index-1));
						
					lex.Assign(sizemaxwidth);
					lex.Val(param.iMaxPixelSize.iWidth);
						
					lex.Assign(sizemaxheight);
					lex.Val(param.iMaxPixelSize.iHeight);
					status=ETrue;
					}						
				}
			else	//if max size not given
				{						
				index=conversionBuf.Find(star);	
				if(index!=KErrNotFound) 
					{
					//solve min size
					TPtrC sizeminwidth=conversionBuf.Left( index );						
					TPtrC sizeminheight=conversionBuf.Right( conversionBuf.Length() - index-1);		
					
					lex.Assign(sizeminwidth);
					lex.Val(param.iMinPixelSize.iWidth);
					
					lex.Assign(sizeminheight);
					lex.Val(param.iMinPixelSize.iHeight);
					//set max size
					param.iMaxPixelSize.iWidth=param.iMinPixelSize.iWidth;
					param.iMaxPixelSize.iHeight=param.iMinPixelSize.iHeight;
                    status=ETrue;							
					}						
				}				
		    }        	


        	//Check and add to attribute list if there is maxsize
            TPtrC maxsizevalue;
            conversionBuf = KNullDesC;
            for ( TInt iCounter = 0 ; iCounter < aAttributes.Count() ; iCounter++ )        
                {                
                if ( aAttributes[iCounter].Attribute().LocalName().DesC() == KBTSUAttributeMaxSize )
                    {                                            
                    User::LeaveIfError( CnvUtfConverter::ConvertToUnicodeFromUtf8( conversionBuf, aAttributes[iCounter].Value().DesC()));                                    
                    }
                }         
            
            
            if (conversionBuf.Length()>0)
            	{			
    			lex.Assign(conversionBuf);
    			lex.Val(param.iMaxByteSize);			
            	}           
            	
            if(status)
            	{
            	iCapabilityList->Append(param); //add to list
            	}   

        }     
   	 
    }
    
// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::OnEndElementL
// -----------------------------------------------------------------------------
//    
void CBTSUCapabilityResolver::OnEndElementL(const Xml::RTagInfo& /*aElement*/, TInt aErrorCode)
  {
    FLOG(_L("[BTSU]\t CBTSUCapabilityResolver::EndElement()"));    
    if(aErrorCode==KErrNone)
        {        
        iCompleted=ETrue;       
        }
    FLOG(_L("[BTSU]\t CBTSUCapabilityResolver::EndElement()"));    
        
    }
    
// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::OnContentL
// -----------------------------------------------------------------------------
//     
void CBTSUCapabilityResolver::OnContentL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)
    {   
    }

// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::OnStartPrefixMappingL
// -----------------------------------------------------------------------------
// 
void CBTSUCapabilityResolver::OnStartPrefixMappingL(const RString& /*aPrefix*/, const RString& /*aUri*/, 
								   TInt /*aErrorCode*/)
    {    
    }

// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::OnEndPrefixMappingL
// -----------------------------------------------------------------------------
// 
void CBTSUCapabilityResolver::OnEndPrefixMappingL(const RString& /*aPrefix*/, TInt /*aErrorCode*/)
    {
    }

// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::OnIgnorableWhiteSpaceL
// -----------------------------------------------------------------------------
// 
void CBTSUCapabilityResolver::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)
    {
    }

// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::OnSkippedEntityL
// -----------------------------------------------------------------------------
// 
void CBTSUCapabilityResolver::OnSkippedEntityL(const RString& /*aName*/, TInt /*aErrorCode*/)
    {
    }
    
// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::OnProcessingInstructionL
// -----------------------------------------------------------------------------
//     
void CBTSUCapabilityResolver::OnProcessingInstructionL(const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, 
										  TInt /*aErrorCode*/)
    {
    }
    
// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::OnError
// -----------------------------------------------------------------------------
//    
void CBTSUCapabilityResolver::OnError(TInt /*aErrorCode*/)
    {
    }

// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::GetExtendedInterface
// -----------------------------------------------------------------------------
// 
TAny* CBTSUCapabilityResolver::GetExtendedInterface(const TInt32 /*aUid*/)
    {
        return NULL;
    }    
    
// -----------------------------------------------------------------------------
// CBTSUCapabilityResolver::IsCompleted
// -----------------------------------------------------------------------------
    
TBool CBTSUCapabilityResolver::IsCompleted()
    {
    return iCompleted;
    }

//  End of File