/*

* Copyright (c) 2006 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:  This is NPP PSY Positioning Plug-in ( PSY ).

*

*/

// INCLUDE FILES

#include <e32std.h>            

#include <centralrepository.h>

#include "npppsysettinghandler.h"

#include "npppsystatushandler.h"

#include "npppsyinternalcrkeys.h"

#include "npppsylogging.h"

#include "npppsypanic.h"

#include "npppsy.hrh"

// Constants

// Sepperator used in setting

_LIT( KNppPsySettingSeperator, " " );

// The width of each PSY uid in PSY list

const TInt KNppPsyPsyUidWidth = 8;

// The length of buffer which is used for logging into file

const TInt KBufferSize = 64;

// PSY list length when the list is frozen and no fallback

const TInt KNppPsyListLengthWhenFrozenNoFallback = 1;

const TText KNppPsySpaceCharacter = ' ';

// ========================== == MEMBER FUNCTIONS ===============================

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

// CNppPsySettingHandler::CNppPsySettingHandler

// C++default constructor can NOT contain any code, that

// might leave.

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

//

CNppPsySettingHandler::CNppPsySettingHandler( CNppPsyStatusHandler& aStatusHandler )

    : CActive( CActive::EPriorityStandard ),

      iStatusHandler( aStatusHandler )

    {

    CActiveScheduler::Add( this );

    }

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

// CNppPsySettingHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNppPsySettingHandler::ConstructL()

    {

    TRACESTRING( "CNppPsySettingHandler::ConstructL start" )

    //Central repository

    iRepository = CRepository::NewL( KCRUidNppPsy );

    //Start notification

    iRepository->NotifyRequest( KNppPsyPsyList, iStatus );

    SetActive();

    //Parse settings

    ParseSettingL( iListFrozen, iPsyList );

    //Check if key value is changed in ROM key

    ValidateRomKeyValueL();

    //Check if the list is empty

    iStatusHandler.SetPsyListStatus( iPsyList.Count() != 0 );

    TRACESTRING( "CNppPsySettingHandler::ConstructL end" )

    }

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

// CNppPsySettingHandler::NewL

// Two - phased constructor.

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

//

CNppPsySettingHandler* CNppPsySettingHandler::NewL( 

        CNppPsyStatusHandler& aStatusHandler )

    {

    CNppPsySettingHandler* self = new( ELeave ) 

        CNppPsySettingHandler( aStatusHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CNppPsySettingHandler::~CNppPsySettingHandler

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

//

CNppPsySettingHandler::~CNppPsySettingHandler()

    {

    Cancel();

    delete iRepository;

    iPsyList.Close();

    TRACESTRING( "CNppPsySettingHandler:: destructed" )

    }

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

// CNppPsySettingHandler::GetPsyListL

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

//

void CNppPsySettingHandler::GetPsyListL( RArray < TUid> &aList )

    {

    aList.Reset();

    TInt count = iPsyList.Count();

    if(iListFrozen == ENppPsyPsyListFrozenNoFallback)

        {

        //If list is frozen and no fallback, we return only the first PSY

        count = ( count == 0 ? 0 : KNppPsyListLengthWhenFrozenNoFallback );

        }

   TBuf<KBufferSize> buffer;

   buffer.Copy(_L("Get PSY List..."));

   TRACETEXT(buffer)

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

        {

        User::LeaveIfError( aList.Append( iPsyList[i] ) );

	    buffer.Copy(iPsyList[i].Name());

	    TRACETEXT(buffer)

        }

    }

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

// CNppPsySettingHandler::MovePsyLast

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

//

void CNppPsySettingHandler::MovePsyLast( TUid aPsy )

    {

    if ( !iListFrozen )

        {

        TInt index = iPsyList.Find( aPsy );

        if ( index != KErrNotFound )

            {

            iPsyList.Remove( index );

            if ( iPsyList.Append( aPsy ) == KErrNone )

                {

                WriteSetting();

                }

            }

        }

    }

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

// CNppPsySettingHandler::RemovePsy

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

//

void CNppPsySettingHandler::RemovePsy( TUid aPsy )

    {

    TInt index = iPsyList.Find( aPsy );

    if ( index != KErrNotFound )

        {

        iPsyList.Remove( index );

        WriteSetting();

        }

    }

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

// CNppPsySettingHandler::RunL

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

//

void CNppPsySettingHandler::RunL()

    {

    ParseSettingL( iListFrozen, iPsyList );

    //Check if the list is empty

    iStatusHandler.SetPsyListStatus( iPsyList.Count() != 0 );

    //issue another request

    iRepository->NotifyRequest( KNppPsyPsyList, iStatus );

    SetActive();

    }

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

// CNppPsySettingHandler::DoCancel

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

//

void CNppPsySettingHandler::DoCancel()

    {

    if ( iRepository )

        {

        iRepository->NotifyCancelAll(); //error ignored

        }

    }

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

// CNppPsySettingHandler::RunError

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

//

TInt CNppPsySettingHandler::RunError( TInt aError )

    {

    //This function may be called when PSY list is corrupted

    if ( aError != KErrNoMemory && aError != KErrCancel )

        {

        iStatusHandler.SetPsyListStatus( EFalse );

        }

    //issue another request

    iRepository->NotifyRequest( KNppPsyPsyList, iStatus );

    SetActive();

    return KErrNone;

    }

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

// CNppPsySettingHandler::ParseSettingL

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

//

void CNppPsySettingHandler::ParseSettingL(

            TInt& aListFrozen, 

            RArray < TUid >& aPsyList )

    {

    TBuf < KNppPsyPsyListMaxLength > setting;

    User::LeaveIfError( iRepository->Get( KNppPsyPsyList, setting ) );

    TRACESTRING("PSY List from CenRep...")

    TRACETEXT(setting)

    //Reset list

    aPsyList.Reset();

    TLex lex( setting );

    lex.SkipSpace();

    TInt frozen;

    User::LeaveIfError( lex.Val( frozen ) ); //frozen status

    aListFrozen = frozen;

    lex.SkipSpace();

    TUint32 psyUid;

    while ( !lex.Eos() )

        {

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

        User::LeaveIfError( aPsyList.Append( TUid::Uid( psyUid ) ) );

        lex.SkipSpace();

        }

    }

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

// CNppPsySettingHandler::ValidateRomKeyValueL

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

//

void CNppPsySettingHandler::ValidateRomKeyValueL()

    {

	TInt romListFrozen;

    RArray < TUid > romPsyList;

    CleanupClosePushL(romPsyList);

	TBuf < KNppPsyPsyListMaxLength > setting;

	User::LeaveIfError( iRepository->Get( KNppPsyPsyList, setting ) );

	setting.TrimRight();

	setting.Append(KNppPsySpaceCharacter);

	User::LeaveIfError(iRepository->Set( KNppPsyPsyList,setting ));

    iRepository->Reset( KNppPsyPsyList );

    ParseSettingL( romListFrozen, romPsyList );

    RemoveDuplicatePsyUid(iPsyList,romPsyList);

	iListFrozen = romListFrozen;

    CleanupStack::PopAndDestroy(&romPsyList);

    }

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

// CNppPsySettingHandler::WriteSetting

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

//

void CNppPsySettingHandler::WriteSetting()

    {

    TBuf < KNppPsyPsyListMaxLength > setting;

    //Frozen status

    setting.AppendNum( iListFrozen );

    setting.Append( KNppPsySettingSeperator );

    TInt count = iPsyList.Count();

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

        {

        setting.AppendNumFixedWidth( iPsyList[i].iUid, EHex, KNppPsyPsyUidWidth );

        setting.Append( KNppPsySettingSeperator );

        }

	TRACESTRING("Writing PSY List...")

	TRACETEXT(setting)

    iRepository->Set( KNppPsyPsyList, setting ); //error ignored

    }

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

// CNppPsySettingHandler::RemoveDuplicatePsyUid

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

//

void CNppPsySettingHandler::RemoveDuplicatePsyUid(

            RArray < TUid >& aToPsyList ,

            RArray < TUid >& aFromPsyList )

    {

	    TInt count = aFromPsyList.Count();

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

	        {

                TInt index = aToPsyList.Find( aFromPsyList[i] );

	            if (  index == KErrNotFound )

        	  	{

        	  		aToPsyList.Append( aFromPsyList[i] );		

        	  	}

	        }

	    WriteSetting();    

    }

//  End of File