/*
* Copyright (c) 2007 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:  Location Centre Server object.
*
*/


// SYSTEM INCLUDES
#include<s32mem.h>

// USER INCLUDES
#include "lcregapporder.h"
#include "lcprivatecrkeys.h"
#include "lcregappstore.h"

// CONSTANT DEFINTIONS
const TInt KLcNoofDigitsInInteger = 4;
const TInt KLcMaxBufLength = 1024;

// ----- Member funtions for CLcRegAppOrder ---------------------------------

// ---------------------------------------------------------------------------
// CLcRegAppOrder::CLcRegAppOrder
// ---------------------------------------------------------------------------
//
CLcRegAppOrder::CLcRegAppOrder( CLcRegAppStore& aLcRegAppStore )
	:iLcRegAppStore( &aLcRegAppStore )
    {
    // C++ Default constructor. No allocations or functions which can Leave
    // should be called from here.Initiallize all the variable here
    }
         
// ---------------------------------------------------------------------------
// CLcRegAppOrder::~CLcRegAppOrder
// ---------------------------------------------------------------------------
//
CLcRegAppOrder::~CLcRegAppOrder()
    {
    // C++ Destructor. Free all resources associated with this class.
	delete iRepository;
	iRepository = NULL;	
	// clear the top key value.
	iTopArray.ResetAndDestroy();
	iTopArray.Close();
	// clear the bottom key value
	iBottomArray.ResetAndDestroy();
	iBottomArray.Close();
	// clear middle uuid array
	iMiddleArray.ResetAndDestroy();
	iMiddleArray.Close();
    }
        
// ---------------------------------------------------------------------------
// CLcRegAppOrder* CLcRegAppOrder::NewL
// ---------------------------------------------------------------------------
//
CLcRegAppOrder* CLcRegAppOrder::NewL( CLcRegAppStore& aLcRegAppStore )
    {
    // Symbian Two phased constructor. Leaves the object on the Clean-up
    // stack.
    CLcRegAppOrder* self = new ( ELeave )CLcRegAppOrder( aLcRegAppStore );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;         
    }

// ---------------------------------------------------------------------------
// void CLcRegAppOrder::ConstructL
// ---------------------------------------------------------------------------
//
void CLcRegAppOrder::ConstructL()
    {
	// Create the Central repository object for manipulating Avkon Central
	// repository for application order key
	iRepository = CRepository::NewL( KCRUidLocationCentre );
    HBufC* buffer = HBufC::NewLC( NCentralRepositoryConstants::KMaxUnicodeStringLength );
    TPtr bufferPtr( buffer->Des() );
    // get the top order services
    User::LeaveIfError( iRepository->Get( ELcTop, bufferPtr ) );    
	ParseCenRepKeyL( iTopArray, bufferPtr );
	// get the middle order services
	User::LeaveIfError( iRepository->Get( ELcBottom, bufferPtr ) );
	ParseCenRepKeyL( iBottomArray, bufferPtr );
	// get the bottom order services if any
	TBool isMidleKeySet = EFalse;
	User::LeaveIfError( iRepository->Get( ELcMiddle, isMidleKeySet ) );
	
	if( isMidleKeySet )
		{
        // Allocate the id Array buffer    
        CBufFlat* idArrayBuf = CBufFlat::NewL( KLcMaxBufLength );
        CleanupStack::PushL( idArrayBuf );
        idArrayBuf->ResizeL( KLcMaxBufLength );
        
        TPtr8   idArrayPtr( idArrayBuf->Ptr(0));
        
        iLcRegAppStore->GetUuidValueL( idArrayPtr );        
        
        if( idArrayPtr.Length() > 0 )
	        {
	        // Create a Read buffer stream to read the App Ids    
	        RBufReadStream  appReadStream( *idArrayBuf, 0 );
	        CleanupClosePushL( appReadStream );
	        
	        iMiddleArray.ResetAndDestroy();  
	                        
	        // Internalize the structure to obtain the Actual list of Ids    
	        iMiddleArray.InternalizeL( appReadStream );  
	        CleanupStack::PopAndDestroy(); // appReadStream
	        }
        CleanupStack::PopAndDestroy( idArrayBuf );
		}
	else
		{
		// Deep RFS handling
	    iLcRegAppStore->AddDataToTableL( KNullDesC8 );	
		}
		
    CleanupStack::PopAndDestroy( buffer );   
    }  

// ---------------------------------------------------------------------------
// void CLcRegAppOrder::ParseCenRepKey
// ---------------------------------------------------------------------------
//
void CLcRegAppOrder::ParseCenRepKeyL( RPointerArray< HBufC >&	aArray,
    				     			 const TDesC&				aKey )
	{
	// If the length of the buffer is less than 4 digits, then terminate
	// the function.
	if( aKey.Length() < KLcNoofDigitsInInteger )
		{
		return;
		}
	TUint count = ParseInteger( aKey );
	TInt currentlength = KLcNoofDigitsInInteger;
		
	for ( TInt i = 0; i < count; i ++ )
		{
		// If the length of the buffer is less than 4 digits, then terminate
		// the function.		
		if( aKey.Right( aKey.Length() - currentlength ).Length() < KLcNoofDigitsInInteger )
			{
			return;
			}
			
		TUint32 len = ParseInteger( aKey.Right( aKey.Length() - currentlength ));
		currentlength += KLcNoofDigitsInInteger;
		
		TPtrC buffer( aKey.Right( aKey.Length() - currentlength ));
		
		// If the length of the buffer is less than the length obtained from the
		// previous operation then terminate the function.
		if( buffer.Length() < len )
			{
			return;
			}
		HBufC* identifier = HBufC::NewLC( currentlength );
		identifier->Des().Copy( buffer.Ptr(), len );
		
		TInt error = aArray.Append( identifier );
		if( error )
			{
			CleanupStack::PopAndDestroy( identifier );
			}
		else
			{
			CleanupStack::Pop( identifier );
			}
		currentlength += len;			
		}
	}
    				     
// ---------------------------------------------------------------------------
// void CLcRegAppOrder::ParseInteger
// ---------------------------------------------------------------------------
//
TUint32	CLcRegAppOrder::ParseInteger( const TDesC&	aBuffer )
	{
	TPtrC buffer( aBuffer.Ptr(), KLcNoofDigitsInInteger );
		
	TBuf8< KLcNoofDigitsInInteger > integerBuf;
	integerBuf.Copy( buffer );
	
	TUint8*	currentPtr = const_cast< TUint8 *>( integerBuf.Ptr());
	TUint32 integer = 0;
	for( TInt i = 0; i < KLcNoofDigitsInInteger; i++ )
		{
		integer += ( integer * 10 ) + ( currentPtr[i] - '0' );
		}
	return integer;
	}
	
// ---------------------------------------------------------------------------
// void CLcRegAppOrder::GetRegisteredAppOrder
// ---------------------------------------------------------------------------
//
TInt CLcRegAppOrder::GetRegisteredAppOrder(const TDesC& aUuid,
												 TInt& aRowPos )
    {
    // search the identifier in the top array.
    for(TInt i = 0; i <iTopArray.Count(); i++  )
	    {
	    HBufC* identifier = iTopArray[i];
	    if( !identifier->Des().Compare( aUuid ) )
		    {
			aRowPos = i;
			return KErrNone;	    			    	
		    }
	    }
	    
    // search the identifier in the middle array.
    for(TInt i = 0; i <iMiddleArray.Count(); i++  )
	    {
	    HBufC* identifier = iMiddleArray[i];
	    if( !identifier->Des().Compare( aUuid ) )
		    {
			aRowPos = iTopArray.Count() + i;
			return KErrNone;	    			    	
		    }
	    }
	    	
    // search the identifier in the top array.
    for(TInt i = 0; i <iBottomArray.Count(); i++  )
	    {
	    HBufC* identifier = iBottomArray[i];
	    if( !identifier->Des().Compare( aUuid ) )
		    {
			aRowPos = iTopArray.Count() + iMiddleArray.Count() + i;
			return KErrNone;	    			    	
		    }
	    }
	return KErrNotFound;	    
    }  

// ---------------------------------------------------------------------------
// void CLcRegAppOrder::RemoveArray
// ---------------------------------------------------------------------------
//
void CLcRegAppOrder::RemoveArrayL(const TDesC& aUuid )
    {
    // search the identifier in the middle array.
    for(TInt i = 0; i <iMiddleArray.Count(); i++  )
	    {
	    HBufC* identifier = iMiddleArray[i];
	    if( !identifier->Des().Compare( aUuid ) )
		    {
			iMiddleArray.Remove(i);
			// now delete the identifier
			delete identifier;
			identifier = NULL;
			break;	    			    	
		    }
	    }
	    
    // Create the buffer for packing the Application Information
    // structure and pack the contents into this buffer
    CBufFlat* buffer = CBufFlat::NewL( iMiddleArray.BufferLength());
    CleanupStack::PushL( buffer );
    
    RBufWriteStream writeStream( *buffer, 0 );
    CleanupClosePushL( writeStream );                
    iMiddleArray.ExternalizeL( writeStream );
    CleanupStack::PopAndDestroy(); // writeStream    	
    iLcRegAppStore->AddDataToTableL( buffer->Ptr(0));
	CleanupStack::PopAndDestroy( buffer );
	// Now get the id index.
	if( iMiddleArray.Count() == 0 )
		{
		User::LeaveIfError( iRepository->Set( ELcMiddle, 0 ));			
		}
    }  

// ---------------------------------------------------------------------------
// void CLcRegAppOrder::AppendArray
// ---------------------------------------------------------------------------
//
TInt CLcRegAppOrder::AppendArrayL(const TDesC& aUuid )
    {
    HBufC* identifier = HBufC::NewL( aUuid.Length() );
    identifier->Des().Copy( aUuid );	
	User::LeaveIfError( iMiddleArray.Append( identifier ));
    // Create the buffer for packing the Application Information
    // structure and pack the contents into this buffer
    CBufFlat* buffer = CBufFlat::NewL( iMiddleArray.BufferLength());
    CleanupStack::PushL( buffer );
    
    RBufWriteStream writeStream( *buffer, 0 );
    CleanupClosePushL( writeStream );                
    iMiddleArray.ExternalizeL( writeStream );
    CleanupStack::PopAndDestroy(); // writeStream
   	
	iLcRegAppStore->AddDataToTableL( buffer->Ptr(0));
	
	CleanupStack::PopAndDestroy( buffer );

	TInt index;
	if ( GetRegisteredAppOrder(aUuid, index ) == KErrNotFound )
		{
		User::Leave( KErrNotFound );
		}
	User::LeaveIfError( iRepository->Set( ELcMiddle, 1 ));	
	return index;			
    }
    
//End of file