/*

* Copyright (c) 2005 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:  IMPS SAP Settings Store implementation.

*

*/

// INCLUDE FILES

#include 	<e32std.h>

#include    <centralrepository.h>

//#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

//#include <centralrepositoryinternal.h>

//#endif

#include    "CIMPSSAPCenRep.h"

#include	"cimpssapsettings.h"

#include	"CIMPSSAPSettingsBody.h"

#include	"cimpssapsettingslist.h"

#include	"CIMPSSAPKeyValuePairs.h"

#include	"CIMPSSAPKeyValuePair.h"

#include	"CIMPSSAPNotifier.h"

#include	"IMPSSAPSettingsStoreCenRepUids.h"

#include    "IMPSSAPSettingsStoreDebugPrint.h"

#include    "IMPSSAPSettingsStorePanics.h"

#include	"RIMPSReleaseArray.h"

#include 	"TIMPSSAPSettingsListItemNameKey.h"

#include	"TIMPSCenRepOperations.h"

// This implementation uses the following way of dividing the

// central repository id range for storing

// SAP Settings data:

//

// - 6 bits for base id(defines the SAP access group)

// - 10 bits for sap uid(unique within all groups)

// - 16 bits for settings, which is further divided into 256

// subsets each containing 256 items. Currently 2 subsets are in use.

// First of the subsets contains settings that have fixed identifiers

// and the second one key-value pairs.

/*

Example:

------------------------------

cenrep entry: 3221356546 int 8081 0

=

110000 		| 0000000010 	| 0000000000000010

------ 		  ----------   	  ----------------

SAP			| SAP Uid    	| Setting Id

Base

6 bits, 	  10 bits	  	  16 bits

110000		 ..010 = 	 	 (10 = 2 dec = ESAPPort in TFixedSAPSetting)

(0x30)		   2 dec

PEC base

id

*/

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

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

// CIMPSSAPCenRep::CIMPSSAPCenRep

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

// might leave.

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

//

CIMPSSAPCenRep::CIMPSSAPCenRep()

    {

    }

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

// CIMPSSAPCenRep::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIMPSSAPCenRep::ConstructL( TInt aPriority )

    {

    iRepository = CRepository::NewL( KCRUidIMPSStore );

    iNotifier = CIMPSSAPNotifier::NewL( aPriority, KCRUidIMPSStore );

    iCommsDatabase = CCommsDatabase::NewL( EDatabaseTypeIAP );

    SetUpDefaultsL();

    }

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

// CIMPSSAPCenRep::NewL

// Two-phased constructor.

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

//

CIMPSSAPCenRep* CIMPSSAPCenRep::NewL( TInt aPriority )

    {

    CIMPSSAPCenRep* self = CIMPSSAPCenRep::NewLC( aPriority );

    CleanupStack::Pop();

    return self;

    }

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

// CIMPSSAPCenRep::NewLC

// Two-phased constructor.

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

//

CIMPSSAPCenRep* CIMPSSAPCenRep::NewLC( TInt aPriority )

    {

    CIMPSSAPCenRep* self = new( ELeave ) CIMPSSAPCenRep();

    CleanupStack::PushL( self );

    self->ConstructL( aPriority );

    return self;

    }

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

// CIMPSSAPCenRep::~CIMPSSAPCenRep

// Destructor

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

//

CIMPSSAPCenRep::~CIMPSSAPCenRep()

    {

    delete iRepository;

    delete iNotifier;

    delete iCommsDatabase;

    }

// HELPER FUNCTIONS

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

// CIMPSSAPCenRep::MaskedId()

// Calculates masked central repository id for setting

// (other items were commented in a header).

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

//

TUint32 CIMPSSAPCenRep::MaskedId( TInt aSetting, TUint32 aUid,

                                  TIMPSAccessGroup aGroup )

    {

    __ASSERT_ALWAYS( ( ( aGroup & EIMPSAccessFilterAll ) == EIMPSIMAccessGroup ) ||

                     ( ( aGroup & EIMPSAccessFilterAll ) == EIMPSPECAccessGroup ),

                     Panic( EIMPSInvalidAccessGroup ) );

    TUint32 maskBase( 0 );

    if ( aGroup & EIMPSIMAccessGroup )

        {

        maskBase += KSAPSettingsIMBaseId << KBaseOffset;

        }

    else

        {

        maskBase += KSAPSettingsPECBaseId << KBaseOffset;

        }

    maskBase += aUid << KSAPOffset;

    maskBase += aSetting;

    return maskBase;

    }

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

// CIMPSSAPCenRep::SAPNameExistsL()

// Checks if SAP with given name already exists in given access group.

// (other items were commented in a header).

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

//

TBool CIMPSSAPCenRep::SAPNameExistsL( const TDesC& aSAPName, TUint32 aUid,

                                      TIMPSAccessGroup aGroup )

    {

    __ASSERT_ALWAYS( ( ( aGroup & EIMPSAccessFilterAll ) == EIMPSIMAccessGroup ) ||

                     ( ( aGroup & EIMPSAccessFilterAll ) == EIMPSPECAccessGroup ),

                     Panic( EIMPSInvalidAccessGroup ) );

    CIMPSSAPSettingsList* list = CIMPSSAPSettingsList::NewLC();

    PopulateSAPSettingsListL( *list, aGroup );

    TInt count( list->Count() );

    TBool alreadyExists( EFalse );

    TInt index( 0 );

    if ( list->FindNameL( aSAPName, index ) == 0 )

        {

        if ( list->UidForIndex( index ) != aUid )

            {

            alreadyExists = ETrue;

            }

        }

    CleanupStack::PopAndDestroy( list );

    return alreadyExists;

    }

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

// CIMPSSAPCenRep::SAPProtectionL()

// Checks SAP protection level.

// (other items were commented in a header).

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

//

TIMPSSAPProtection CIMPSSAPCenRep::SAPProtectionL( TUint32 aUid,

                                                   TIMPSAccessGroup aGroup )

    {

    __ASSERT_ALWAYS( ( ( aGroup & EIMPSAccessFilterAll ) == EIMPSIMAccessGroup ) ||

                     ( ( aGroup & EIMPSAccessFilterAll ) == EIMPSPECAccessGroup ),

                     Panic( EIMPSInvalidAccessGroup ) );

    TInt ret( ESAPNoProtection );

    User::LeaveIfError( iRepository->Get( EProtection + aUid, ret ) );

    return static_cast< TIMPSSAPProtection >( ret );

    }

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

// CIMPSSAPCenRep::NewUidL()

// Gets new Uid for new SAP

// (other items were commented in a header).

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

//

TUint32 CIMPSSAPCenRep::NewUidL()

    {

    TInt newUid;

    TInt ret;

    ret = iRepository->Get( KSAPHighestUid, newUid );

    if ( ret == KErrNotFound ) // Highest uid not found, create it

        {

        // Check if we have existing SAPs despite not having the highest uid.

        // This may happen if we have older settings.

        if ( SAPCountL( EIMPSAccessFilterAll ) > 0 ) // existing SAPs

            {

            RArray<TUint32> foundSAPs;

            CleanupClosePushL( foundSAPs );

            // FindL return value is currently undocumented,

            // thus silently consumed for now

            iRepository->FindL( ESAPName, KSAPPopulateAllMask, foundSAPs );

            TInt count( foundSAPs.Count() );

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

                {

                //transform found cenrep uids to SAP uids

                foundSAPs[i] &= KSAPUidMask;

                foundSAPs[i] = foundSAPs[i] >> KSAPOffset;

                }

            foundSAPs.SortUnsigned();

            // Find the highest existing uid

            for ( TUint32 i( KLastSAPId ); i >= KFirstSAPId;i-- )

                {

                if ( foundSAPs.Find( i ) == KErrNone )

                    {

                    if ( i < KLastSAPId )

                        {

                        newUid = i + 1;

                        }

                    else

                        {

                        newUid = KFirstSAPId;

                        }

                    break;

                    }

                }

            CleanupStack::PopAndDestroy(); // foundSAPs

            }

        else // No existing SAPs

            {

            newUid = KFirstSAPId;

            }

        User::LeaveIfError( iRepository->Create( KSAPHighestUid, newUid ) );

        }

    else // Otherwise if it's an error situation

        {

        User::LeaveIfError( ret );

        }

    if ( newUid < KFirstSAPId )

        {

        // Something is wrong if we get here

        User::Leave( KErrGeneral );

        }

    else if ( newUid >= KLastSAPId ) // If at the end of the range

        {

        // start from the beginning

        newUid = KFirstSAPId;

        }

    // Check if there are ANY free uids

    if ( ( KLastSAPId - KFirstSAPId ) <= SAPCountL( EIMPSAccessFilterAll ) )

        {

        User::Leave( KErrInUse ); // All UIDs in use

        }

    // Check if there is the next uid is unused.

    TBool okId( EFalse );

    TInt err( KErrNone );

    while ( !okId )

        {

        newUid++;

        TUint32 maskedUid = newUid << KSAPOffset;

        RArray<TUint32> foundSAPs;

        CleanupClosePushL( foundSAPs );

        err = iRepository->FindL( maskedUid, KSAPExistsMask, foundSAPs );

        if ( err == KErrNotFound ) // The uid is free

            {

            okId = ETrue;

            }

        else if ( err == KErrNone ) // There was a SAP with that uid

            {

            // Check range

            if ( newUid >= KLastSAPId )

                {

                newUid = KFirstSAPId; // Start from the beginning.

                }

            }

        else

            {

            User::Leave( err );

            }

        CleanupStack::PopAndDestroy(); //foundSAPs

        }

    // Save the new highest

    User::LeaveIfError( iRepository->Set( KSAPHighestUid, newUid ) );

    return newUid; // return the new uid

    }

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

// CIMPSSAPCenRep::SAPTypeL()

// Gets SAP type

// (other items were commented in a header).

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

//

TIMPSAccessGroup CIMPSSAPCenRep::SAPTypeL( TUint32 aUid )

    {

    TIMPSAccessGroup type( EIMPSNoAccessGroup );

    aUid &= KSAPBaseMask;

    aUid = aUid >> KBaseOffset;

    if ( aUid == KSAPSettingsPECBaseId )

        {

        type = EIMPSPECAccessGroup;

        }

    else if ( aUid == KSAPSettingsIMBaseId )

        {

        type = EIMPSIMAccessGroup;

        }

    else

        {

        // aUid was found in unknown access group. Should not happen.

        User::Leave( KErrGeneral );

        }

    return type;

    }

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

// CIMPSSAPCenRep::SAPExistsL()

// Checks if SAP exists in central repository

// (other items were commented in a header).

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

//

void CIMPSSAPCenRep::SAPExistsL( TUint32 aUid )

    {

    RArray<TUint32> foundSAPs;

    CleanupClosePushL( foundSAPs );

    // FindL return value is currently undocumented,

    // thus silently consumed for now

    iRepository->FindL( aUid, KSAPExistsMask, foundSAPs );

    if ( foundSAPs.Count() != 1 )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy(); //foundSAPs

    }

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

// CIMPSSAPCenRep::SetUpDefaultsL()

// Sets up default SAP ids if they do not exist in the repository

// (other items were commented in a header).

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

//

void CIMPSSAPCenRep::SetUpDefaultsL()

    {

    TInt uid( 0 );

    TInt err ( iRepository->Get( KDefaultIMSAPId, uid ) );

    if ( err == KErrNotFound )

        {

        User::LeaveIfError( iRepository->Create( KDefaultIMSAPId,

                                                 KIMPSSettingsNullUid ) );

        }

    else

        {

        User::LeaveIfError( err );

        }

    err = iRepository->Get( KDefaultPECSAPId, uid );

    if ( err == KErrNotFound )

        {

        User::LeaveIfError( iRepository->Create( KDefaultPECSAPId,

                                                 KIMPSSettingsNullUid ) );

        }

    else

        {

        User::LeaveIfError( err );

        }

    }

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

// CIMPSSAPCenRep::FindSAPsFromAccessGroupL()

// Finds and populates SAP ids to an array from desired access group

// (other items were commented in a header).

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

//

void CIMPSSAPCenRep::FindSAPsFromAccessGroupL( TIMPSAccessGroup aGroup,

                                               RArray<TUint32>& aFoundSAPs )

    {

    if ( aGroup == EIMPSAccessFilterAll )

        {

        iRepository->FindL( ESAPAddress, KSAPPopulateAllMask, aFoundSAPs );

        }

    else if ( aGroup == EIMPSIMAccessGroup )

        {

        iRepository->FindL( MaskedId( ESAPAddress, KIMPSSettingsNullUid,

                                      EIMPSIMAccessGroup ), KSAPPopulateGroupMask, aFoundSAPs );

        }

    else if ( aGroup == EIMPSPECAccessGroup )

        {

        iRepository->FindL( MaskedId( ESAPAddress, KIMPSSettingsNullUid,

                                      EIMPSPECAccessGroup ), KSAPPopulateGroupMask, aFoundSAPs );

        }

    }

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

// CIMPSSAPCenRep::StartOwnTransaction()

// Starts new transaction if there is no ongoing transaction

// (other items were commented in a header).

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

//

TBool CIMPSSAPCenRep::StartOwnTransactionL( TInt aMode )

    {

//    TInt transaction( iRepository->TransactionState() );

 	if( !iInTransaction )

 		{

 		iInTransaction = ETrue;

 		CleanupStack::PushL( TCleanupItem( ReSetTransactionState, this ));

 		iRepository->StartTransaction( static_cast<CRepository::TTransactionMode>( aMode ) );

 		return ETrue;

 		}

	return EFalse;

    }

// OBSERVER SUPPORT

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

// CIMPSSAPCenRep::AddObserverL()

// Adds SAP observer

// (other items were commented in a header).

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

//

void CIMPSSAPCenRep::AddObserverL( MIMPSSAPObserver* aObserver,

                                   TIMPSAccessGroup aGroup )

    {

    SSS_DP_TXT( "CIMPSSAPCenRep::AddObserverL()" );

    iNotifier->AddObserverL( aObserver, aGroup );

    }

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

// CIMPSSAPCenRep::RemoveObserverL()

// Removes SAP observer

// (other items were commented in a header).

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

//

void CIMPSSAPCenRep::RemoveObserver( MIMPSSAPObserver* aObserver )

    {

    SSS_DP_TXT( "CIMPSSAPCenRep::RemoveObserver()" );

    iNotifier->RemoveObserver( aObserver );

    }

// SAP SETTINGS

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

// CIMPSSAPCenRep::StoreNewSAPL()

// Stores new SAP in central repository

// (other items were commented in a header).

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

//

TUint32 CIMPSSAPCenRep::StoreNewSAPL( CIMPSSAPSettings* aSAPSettings,

                                      TIMPSAccessGroup aGroup )

    {

    SSS_DP_TXT( "CIMPSSAPCenRep::StoreNewSAPL()" );

    __ASSERT_ALWAYS( ( ( aGroup & EIMPSAccessFilterAll ) == EIMPSIMAccessGroup ) ||

                     ( ( aGroup & EIMPSAccessFilterAll ) == EIMPSPECAccessGroup ),

                     Panic( EIMPSInvalidAccessGroup ) );

    // SAP name must be defined

    if ( aSAPSettings->SAPName().Length() == 0 )

        {

        User::Leave( KErrArgument );

        }

    // no documentation for StartTransaction() return values, leave if any error

	iInTransaction = ETrue;

	CleanupStack::PushL(TCleanupItem( ReSetTransactionState, this ));

    User::LeaveIfError( iRepository->StartTransaction( CRepository::EReadWriteTransaction ) );

    iRepository->CleanupCancelTransactionPushL();

    //Check if SAP with given name already exists

    // KIMPSSettingsNullUid cannot exist so this checks for all duplicates

    if ( SAPNameExistsL( aSAPSettings->SAPName(), KIMPSSettingsNullUid,

                         aGroup ) )

        {

        User::Leave( KErrAlreadyExists );

        }

    RIMPSReleaseArray tempArray;