/*

* 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:    SIMPLE Protocol implementation for Presence Framework

*

*/

#include <e32std.h>

#include <centralrepository.h>

#include "simpleplugincommon.h"

#include "simplepluginvariation.h"

#include "presencefwsimpleadptprivatecrkeys.h"

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

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

// CSimplePluginVariation::CSimplePluginVariation

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

//

CSimplePluginVariation::CSimplePluginVariation( )

: iDefaultRuleAction(ERuleConfirm), iBlockRuleAction(ERulePoliteBlock)

    {

    }

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

// CSimplePluginVariation::ConstructL

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

//

void CSimplePluginVariation::ConstructL( )

    {

    }

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

// CSimplePluginVariation::NewL

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

//

CSimplePluginVariation* CSimplePluginVariation::NewL( )

    {

    CSimplePluginVariation* self =

        new( ELeave ) CSimplePluginVariation();

    CleanupStack::PushL( self );

    self->ConstructL(  );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimplePluginVariation::~CSimplePluginVariation

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

//

CSimplePluginVariation::~CSimplePluginVariation()

    {

    delete iGrantAllRuleName;

    delete iGrantOwnRuleName;

    delete iDefaultRuleName;

    delete iBlockRuleName;

    delete iRlsGroupUriTemplate;

    delete iSharedXdmTop;

    delete iGrantListName;

    }

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

// CSimplePluginVariation::InitL

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

//

void CSimplePluginVariation::InitL()

    {

    // Read Central Repository settings

    CRepository* repository = NULL;

    TBuf<KSimplePluginMaxRuleLength> myBuffer;

    TRAP_IGNORE( repository =

        CRepository::NewL( KCRUIDPresencefwSimpleadptVariation ));

    CleanupStack::PushL( repository );

    // initialize strings

    delete iGrantAllRuleName;

    iGrantAllRuleName = NULL;

    delete iGrantOwnRuleName;

    iGrantOwnRuleName = NULL;

    delete iDefaultRuleName;

    iDefaultRuleName = NULL;

    delete iBlockRuleName;

    iBlockRuleName = NULL;

    delete iRlsGroupUriTemplate;

    iRlsGroupUriTemplate = NULL;

    delete iSharedXdmTop;

    iSharedXdmTop = NULL;

    delete iGrantListName;

    iGrantListName = NULL;

    // Read values from CenRep

    InitGrantRuleNameL( repository );

    InitGrantOwnRuleNameL( repository );

    InitDefaultRuleNameL( repository );

    InitBlockRuleNameL( repository );

    InitDefaultRuleActionL( repository );

    InitBlockRuleActionL( repository );           

    InitRlsGroupUriTemplateL( repository );

    InitSharedXdmTopL( repository );

    InitGrantListNameL( repository );

    CleanupStack::PopAndDestroy( repository );

    }

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

// CSimplePluginVariation::GrantRuleName

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

//

TPtrC CSimplePluginVariation::GrantRuleName()

    {

    return iGrantAllRuleName ? iGrantAllRuleName->Des() : TPtrC();

    }

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

// CSimplePluginVariation::GrantOwnRuleName

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

//

TPtrC CSimplePluginVariation::GrantOwnRuleName()

    {

    return iGrantOwnRuleName ? iGrantOwnRuleName->Des() : TPtrC();

    }

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

// CSimplePluginVariation::DefaultRuleName

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

//

TPtrC CSimplePluginVariation::DefaultRuleName()

    {

    return iDefaultRuleName ? iDefaultRuleName->Des() : TPtrC();

    }

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

// CSimplePluginVariation::BlockRuleName

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

//

TPtrC CSimplePluginVariation::BlockRuleName()

    {

    return iBlockRuleName ? iBlockRuleName->Des() : TPtrC();

    }

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

// CSimplePluginVariation::DefaultRuleAction

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

//

CSimplePluginVariation::TSimplePluginAuthRule CSimplePluginVariation::DefaultRuleAction()

    {

    return iDefaultRuleAction;

    }

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

// CSimplePluginVariation::BlockRuleAction

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

//

CSimplePluginVariation::TSimplePluginAuthRule CSimplePluginVariation::BlockRuleAction()

    {

    return iBlockRuleAction;

    }

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

// CSimplePluginVariation::RlsGroupUriTemplate

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

//

TPtrC CSimplePluginVariation::RlsGroupUriTemplate()

    {

    return iRlsGroupUriTemplate ? iRlsGroupUriTemplate->Des() : TPtrC();

    }

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

// CSimplePluginVariation::SharedXdmTop

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

//

TPtrC CSimplePluginVariation::SharedXdmTop()

    {

    return iSharedXdmTop ? iSharedXdmTop->Des() : TPtrC();

    }

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

// CSimplePluginVariation::GrantListName

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

//

TPtrC CSimplePluginVariation::GrantListName()

    {

    return iGrantListName ? iGrantListName->Des() : TPtrC();

    }

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

// CSimplePluginVariation::InitGrantRuleNameL

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

//    

void CSimplePluginVariation::InitGrantRuleNameL( CRepository* aRepository )

    {    

    TBuf<KSimplePluginMaxRuleLength> myBuffer;    

    if ( !aRepository || aRepository->Get( KPrFwSimpleGrantAllRuleName, myBuffer ))

        {

        // Use deault value when not found in Central Repository

        myBuffer = KSimpleXdmGrantRule;

        }

    iGrantAllRuleName = myBuffer.AllocL( );

    }

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

// CSimplePluginVariation::InitGrantOwnRuleNameL

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

//    

void CSimplePluginVariation::InitGrantOwnRuleNameL( CRepository* aRepository )

    {    

    TBuf<KSimplePluginMaxRuleLength> myBuffer;    

    if ( !aRepository || aRepository->Get( KPrFwSimpleGrantOwnRuleName, myBuffer ))

        {

        // Use deault value when not found in Central Repository

        myBuffer = KSimpleXdmOwnGrantRule;

        }

    iGrantOwnRuleName = myBuffer.AllocL( );

    } 

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

// CSimplePluginVariation::InitDefaultRuleNameL

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

//    

void CSimplePluginVariation::InitDefaultRuleNameL( CRepository* aRepository )

    {    

    TBuf<KSimplePluginMaxRuleLength> myBuffer;    

    if ( !aRepository || aRepository->Get( KPrFwSimpleDefaultRuleName, myBuffer ))

        {

        // Use deault value when not found in Central Repository

        myBuffer = KSimpleXdmDefaultRule;

        }

    iDefaultRuleName = myBuffer.AllocL( );

    }

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

// CSimplePluginVariation::InitBlockRuleNameL

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

//    

void CSimplePluginVariation::InitBlockRuleNameL( CRepository* aRepository )

    {    

    TBuf<KSimplePluginMaxRuleLength> myBuffer;    

    if ( !aRepository || aRepository->Get( KPrFwSimpleBlockRuleName, myBuffer ))

        {

        // Use deault value when not found in Central Repository

        myBuffer = KSimpleXdmBlockRule;

        }

    iBlockRuleName = myBuffer.AllocL( );

    }    

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

// CSimplePluginVariation::InitDefaultRuleActionL

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

//    

void CSimplePluginVariation::InitDefaultRuleActionL( CRepository* aRepository )

    {    

    TBuf<KSimplePluginMaxRuleLength> myBuffer;  

    using namespace NSimplePlugin::NSimpleOma;      

    iDefaultRuleAction = ERuleAllow;

    if ( aRepository && !aRepository->Get( KPrFwSimpleDefaultRuleAction, myBuffer ))

        {

        if ( !myBuffer.CompareF( KSimpleBlock ))

            {

            iDefaultRuleAction = ERuleBlock;

            }

        else if ( !myBuffer.CompareF( KSimplePoliteBlock ))

            {

            iDefaultRuleAction = ERulePoliteBlock;

            }

        else if ( !myBuffer.CompareF( KSimpleConfirm ))

            {

            iDefaultRuleAction = ERuleConfirm;

            }

        else if ( !myBuffer.CompareF( KSimpleAllow ))

            {

            iDefaultRuleAction = ERuleAllow;

            }

        }

    }

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

// CSimplePluginVariation::InitBlockRuleActionL

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

//    

void CSimplePluginVariation::InitBlockRuleActionL( CRepository* aRepository )

    {    

    TBuf<KSimplePluginMaxRuleLength> myBuffer;  

    using namespace NSimplePlugin::NSimpleOma;      

    iBlockRuleAction = ERuleBlock;

    if ( aRepository && !aRepository->Get( KPrFwSimpleBlockRuleAction, myBuffer ))

        {

        if ( myBuffer.CompareF( KSimpleBlock ))

            {

            iBlockRuleAction = ERulePoliteBlock;

            }

        else 

            {

            // default value is used            

            }

        }

    else

        {

        // default value is used

        }    

    } 

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

// CSimplePluginVariation::InitRlsGroupUriTemplateL

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

//    

void CSimplePluginVariation::InitRlsGroupUriTemplateL( CRepository* aRepository )

    {    

    TBuf<KSimplePluginMaxRuleLength> myBuffer;  

    if ( !aRepository || aRepository->Get( KPrFwSimpleRlsGroupUriTemplate, myBuffer ))

        {

        myBuffer = KSimpleRlsGroupUriTemplate;

        }

    iRlsGroupUriTemplate = myBuffer.AllocL();    

    }

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

// CSimplePluginVariation::InitSharedXdmTopL

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

//    

void CSimplePluginVariation::InitSharedXdmTopL( CRepository* aRepository )

    {

    TBuf<KSimplePluginMaxRuleLength> myBuffer;

    if ( !aRepository || aRepository->Get( KPrFwSimpleSharedXdmTop, myBuffer ))

        {

        myBuffer = KSimpleOMABuddyList;

        }

    iSharedXdmTop = myBuffer.AllocL();

    }

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

// CSimplePluginVariation::InitGrantListNameL

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

//    

void CSimplePluginVariation::InitGrantListNameL( CRepository* aRepository )

    {    

    TBuf<KSimplePluginMaxRuleLength> myBuffer;  

    if ( !aRepository || aRepository->Get( KPrFwSimpleGrantListName, myBuffer ))

        {

        myBuffer = KSimpleS60GrantedList;

        }

    iGrantListName = myBuffer.AllocL();   

    }               

// End of file